#!/usr/bin/env python


#
#    Copyright (c) 2016-2017 Nest Labs, Inc.
#    All rights reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License");
#    you may not use this file except in compliance with the License.
#    You may obtain a copy of the License at
#
#        http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
#

#
#    @file
#       Implements WeaveTunnelStart class that start Weave Tunnel
#       between border-gateway and a service.
#

import os
import sys
import time

from happy.ReturnMsg import ReturnMsg
from happy.Utils import *
from happy.HappyNetwork import HappyNetwork
from happy.HappyNode import HappyNode

import happy.HappyNodeRoute
import happy.HappyNetworkAddress

import plugin.WeaveTunnelStop as WeaveTunnelStop
from plugin.WeaveTest import WeaveTest
import plugin.WeaveUtilities as WeaveUtilities


options = {"border_gateway": None,
           "service": None,
           "tap": None,
           "primary": None,
           "backup": None,
           "customized_tunnel_port": None,
           "service_dir": False,
           "skip_service_end": False,
           "tunnel_log": True,
           "case": False,
           "service_dir_server": None,
           "service_process_tag": "WEAVE-SERVICE-TUNNEL",
           "gateway_process_tag": "WEAVE-GATEWAY-TUNNEL",
           "case_cert_path": None,
           "case_key_path": None,
           "test_tag": "",
           "iterations": 1,
           "gateway_faults": None,
           "service_faults": None,
           "strace": False,
           "sync_on_gateway_output": "",
           "sync_on_service_output": "",
           "product_id": "12", # kNestWeaveProduct_Flintstone
           "plaid_gateway_env": {},
           "plaid_service_env": {}
           }


def option():
    return options.copy()


class WeaveTunnelStart(HappyNode, HappyNetwork, WeaveTest):
    """
    weave-tunnel-start start a tunnel between border-gateway and a service

    weave-tunnel-start [-h --help] [-q --quiet] [-b --border_gateway <NODE_ID>]
        [-s --service <NODE_ID> | <IP_ADDR>] [-p --tap <TAP_INTERFACE>] [-P --primary <PRIMARY_INTERFACE>] [-B --backup <BACKUP_INTERFACE>]
        [-d --service_dir] [-i --service_dir_server <SERVICE_HOST>] [-C --case] [-E --case_cert_path <path>] [-T --case_key_path <path>]

    Example:
    $ weave-tunnel-start node01 node02
        Start weave tunnel between border-gateway node01 and service node02.

    $ weave-tunnel-start node01 184.72.129.8
        Start weave tunnel between border-gateway node01 and a node with an IP address 184.72.129.8.

    $ weave-tunnel-start --border_gateway node01 --service_dir --service_dir_server  "frontdoor.integration.nestlabs.com" --case --case_cert_path path --case_key_path path
        Start weave tunnel with case encryption between border-gateway node01 and a node with the service loopup directory frontdoor.integration.nestlabs.com.

    $ weave-tunnel-start --border_gateway node01 --service 184.72.129.8 -P wlan0 -B cellular0
        Start weave tunnel between border-gateway node01 and a node with an IP address 184.72.129.8, the primary tunnel go through wlan0, the backup tunnel
        go through cellular0

    return:
        0    success
        1    fail
    """

    def __init__(self, opts = options):
        HappyNode.__init__(self)
        HappyNetwork.__init__(self)
        WeaveTest.__init__(self)
        self.__dict__.update(opts)
        emsg = "starting with opts: %s" %opts
        self.logger.debug("[localhost] WeaveTunnelStart: %s" %emsg)

        self.gateway_process_tag += self.test_tag
        self.service_process_tag += self.test_tag

    def __stopExistingTunnel(self):
        options = WeaveTunnelStop.option()
        options["border_gateway"] = self.border_gateway
        options["service"] = self.service

        stopTunnel = WeaveTunnelStop.WeaveTunnelStop(options)
        stopTunnel.run()

        self.readState()


    def __pre_check(self):
        # Check if border-gateway node was given
        if not self.border_gateway:
            emsg = "Border-gateway node id not specified."
            self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
            self.exit()

        if not self._nodeExists(self.border_gateway):
            emsg = "Border-gateway node %s does not exist." % (self.border_gateway)
            self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
            self.exit()

        # Check if service node was given in the environment
        if not self.service and not self.service_dir:
            if "weave_service_address" in os.environ.keys():
                self.service = os.environ['weave_service_address']
                emsg = "Found weave_service_address %s." % (self.service)
                self.logger.debug("[localhost] Weave: %s" % (emsg))

        if not self.service and self.service_dir:
            if self.service_dir_server:
                self.skip_service_end = True
                self.logger.debug("[localhost] WeaveTunnelStart against tier %s." % self.service_dir_server)
            else:
                if "weave_service_address" in os.environ.keys():
                    self.skip_service_end = True
                    self.service_dir_server = os.environ['weave_service_address']
                    self.logger.debug("[localhost] WeaveTunnelStart against tier %s." % self.service_dir_server)
                else:
                    # Check if service node was given
                    emsg = "Service node id (or IP address or service directory) not specified."
                    self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
                    self.exit()

        if self.service:
            # If service is a domain name, convert it to IP
            if self.isDomainName(self.service):
                ip = self.getHostByName(self.service)
                self.service = ip

            if not self.isIpAddress(self.service) and not self._nodeExists(self.service):
                emsg = "Service node %s does not exist." % (self.service)
                self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
                self.exit()

            if self.isIpAddress(self.service):
                self.service_ip = self.service
                self.skip_service_end = True
            else:
                self.service_ip = self.getNodePublicIPv4Address(self.service)

            if self.service_ip == None:
                emsg = "Could not find IP address of the service node."
                self.logger.error("[localhost] WeaveTunnel: %s" % (emsg))
                self.exit()

        self.fabric_id = self.getFabricId()

        # Check if there is no fabric
        if self.fabric_id == None:
            emsg = "There is not Weave fabric."
            self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
            self.exit()

        # Check if there is a tunnel
        if self.getTunnelServiceNodeId() or self.getTunnelServiceDir():
            emsg = "There already exist a Weave tunnel."
            self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
            self.__stopExistingTunnel()


        self.service_weave_id = self.getServiceWeaveID("Tunnel")
        self.gateway_weave_id = self.getWeaveNodeID(self.border_gateway)

        if self.service_weave_id == None:
            emsg = "Could not find Weave node ID of the service node."
            self.logger.error("[localhost] WeaveTunnel: %s" % (emsg))
            self.exit()

        if self.gateway_weave_id == None:
            emsg = "Could not find Weave node ID of the border-gateway node."
            self.logger.error("[localhost] WeaveTunnel: %s" % (emsg))
            self.exit()


    def __start_tunnel_at_service(self):
        cmd = self.getWeaveTunnelServicePath()
        if not cmd:
            return

        cmd += " --node-id " + str(self.service_weave_id)
        cmd += " --fabric-id " + str(self.fabric_id)

        if self.tap:
            cmd += " --interface " + self.tap

        if self.service_faults:
            cmd += " --faults " + self.service_faults
            cmd += " --iterations " + str(self.iterations)

        cmd += " --debug-resource-usage"
        cmd += " --print-fault-counters"

        cmd = self.runAsRoot(cmd)
        self.start_weave_process(self.service, cmd, self.service_process_tag, strace=self.strace, sync_on_output=self.sync_on_service_output, env=self.plaid_service_env)

        max_wait_time = 40

        while not self._nodeInterfaceExists(self.service_tun, self.service):
            time.sleep(0.1)
            max_wait_time -= 1

            if max_wait_time <= 0:
                emsg = "Service-side tunnel interface %s was not created." % (self.service_tun)
                self.logger.error("[%s] WeaveTunnel: %s" % (self.service, emsg))
                self.exit()

            if (max_wait_time) % 10 == 0:
                emsg = "Waiting for interface %s to be created." % (self.service_tun)
                self.logger.debug("[%s] WeaveTunnel: %s" % (self.service, emsg))

        with self.getStateLockManager():
            self.readState()

            new_node_interface = {}
            new_node_interface["link"] = None
            new_node_interface["type"] = self.network_type["tun"]
            new_node_interface["ip"] = {}
            self.setNodeInterface(self.service, self.service_tun, new_node_interface)

            self.writeState()


    def __assing_tunnel_endpoint_ula_at_service(self):
        addr = self.getServiceWeaveIPAddress("Tunnel", self.service)

        options = happy.HappyNodeAddress.option()
        options["node_id"] = self.service
        options["interface"] = self.service_tun
        options["address"] = addr
        options["add"] = True

        addAddr = happy.HappyNodeAddress.HappyNodeAddress(options)
        addAddr.run()


    def __start_tunnel_at_gateway(self):
        cmd = self.getWeaveTunnelBorderGatewayPath()
        if not cmd:
            return

        cmd += " --node-id " + self.gateway_weave_id
        cmd += " --fabric-id " + str(self.fabric_id)

        if self.tap:
            cmd += " --interface " + self.tap
        if self.primary:
            cmd += " --primary-intf " + self.primary
        if self.backup:
            cmd += " --backup-intf " + self.backup + " --enable-backup "
        if self.tunnel_log:
            cmd += " --tunnel-log"
        if self.product_id:
            cmd += " --product-id " + self.product_id
        if self.case:
            cmd += ' --case'
            if not self.case_cert_path == 'default':
                self.cert_file = self.case_cert_path if self.case_cert_path else os.path.join(self.main_conf['log_directory'], self.gateway_weave_id.upper() + '-cert.weave-b64')
                self.key_file = self.case_key_path if self.case_key_path else os.path.join(self.main_conf['log_directory'], self.gateway_weave_id.upper() + '-key.weave-b64')
                cmd += ' --node-cert ' + self.cert_file + ' --node-key ' + self.key_file

            if self.service_dir:
                cmd += " --service-dir " + str(self.service_weave_id) + ' --service-dir-server ' + self.service_dir_server
            else:
                cmd += " --connect-to " + self.service_ip + " " + str(self.service_weave_id)
        elif self.service:
            if self.customized_tunnel_port:
                self.service_ip = self.service_ip + ":%d" % self.customized_tunnel_port
            cmd += " --connect-to " + self.service_ip + " " + str(self.service_weave_id)

        # fault-injection related
        cmd += " --debug-resource-usage"
        cmd += " --print-fault-counters"

        if self.gateway_faults:
            cmd += " --faults " + self.gateway_faults
            cmd += " --iterations " + str(self.iterations)

        cmd = self.runAsRoot(cmd)
        self.start_weave_process(self.border_gateway, cmd, self.gateway_process_tag, strace=self.strace, sync_on_output=self.sync_on_gateway_output, env=self.plaid_gateway_env)


    def __post_check(self):
        tries = 100
        while not self._nodeInterfaceExists(self.gateway_tun, self.border_gateway):
            self.logger.debug("[localhost] WeaveTunnelStart: sleeping in __post_check")
            time.sleep(1)
            tries -= 1
            if tries < 0:
                emsg = "Tunnel interface %s cannot be found at node %s." % (self.gateway_tun, self.border_gateway)
                self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
                self.exit()


    def __add_tunnel_state(self):
        new_tunnel = {}
        new_tunnel["gateway"] = self.border_gateway
        new_tunnel["service"] = self.service
        new_tunnel["service_dir"] = self.service_dir_server
        self.setTunnel(new_tunnel)


    def __add_tunnel_route(self):
        self.global_prefix = self.getFabricGlobalPrefix()

        options = happy.HappyNodeRoute.option()
        options["node_id"] = self.border_gateway
        options["to"] = self.global_prefix
        options["via"] = self.gateway_tun
        options["prefix"] = self.global_prefix
        options["add"] = True

        self.logger.debug("[localhost] WeaveTunnelStart: adding route with options: " + str(options) )
        weaveServiceRoute = happy.HappyNodeRoute.HappyNodeRoute(options)
        weaveServiceRoute.start()


    def run(self):
        self.logger.debug("[localhost] WeaveTunnelStart: Run.")

        with self.getStateLockManager():
            self.__pre_check()

        if not self.skip_service_end:
            self.__start_tunnel_at_service()
            self.__assing_tunnel_endpoint_ula_at_service()

        self.__start_tunnel_at_gateway()

        with self.getStateLockManager():
            self.readState()

            self.__post_check()

            self.__add_tunnel_state()

            self.writeState()

        self.__add_tunnel_route()

        data = {}

        gateway_output_value, gateway_output_data = \
            self.get_test_output(self.border_gateway, self.gateway_process_tag, quiet=True)
        if self.strace:
            gateway_strace_value, gateway_strace_data = \
                self.get_test_strace(self.border_gateway, self.gateway_process_tag)
            data["gateway_strace"] = gateway_strace_data

        if self.skip_service_end:
            service_output_data = ""
            service_strace_data = ""
            service_output_value = 0
        else:
            service_output_value, service_output_data = \
                self.get_test_output(self.service, self.service_process_tag, quiet=True)
            if self.strace:
                service_strace_value, service_strace_data = \
                    self.get_test_strace(self.service, self.service_process_tag)
                data["service_strace"] = service_strace_data

        data["gateway_output"] = gateway_output_data
        data["service_output"] = service_output_data
        result = gateway_output_value or service_output_value  # 0 == success, hence 'or'

        self.logger.debug("[localhost] WeaveTunnelStart: Done.")
        return ReturnMsg(result, data)