#!/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 WeaveTunnelTest class that executes a set of Weave
#       Tunnel tests 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


options = {}
options["quiet"] = False
options["border_gateway"] = None
options["service"] = None
options["tap"] = None


def option():
    return options.copy()


class WeaveTunnelTest(HappyNode, HappyNetwork, WeaveTest):
    """
    weave-tunnel-test start a tunnel between border-gateway and the service and run all tests

    weave-tunnel-test [-h --help] [-q --quiet] [-b --border_gateway <NODE_ID>]
        [-s --service <NODE_ID> | <IP_ADDR>] [-p --tap <TAP_INTERFACE>]

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

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


    return:
        0    success
        1    fail
    """

    def __init__(self, opts = options):
        HappyNode.__init__(self)
        HappyNetwork.__init__(self)
        WeaveTest.__init__(self)

        self.quiet = opts["quiet"]
        self.border_gateway = opts["border_gateway"]
        self.service = opts["service"]
        self.tap = opts["tap"]

        self.service_process_tag = "WEAVE-TUNNEL-TEST-SERVER"
        self.gateway_process_tag = "WEAVE-TUNNEL-TEST-BORDER-GW"

        self.gateway_node_id = None
        self.service_node_id = None

    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] WeaveTunnelTest: %s" % (emsg))
            sys.exit(1)

        # Check if Weave Tunnel service node is given.
        if not self.service:
            emsg = "Service node id not specified."
            self.logger.error("[localhost] WeaveTunnelTest: %s" % (emsg))
            sys.exit(1)

        # Check if Weave Tunnel border gateway node exists.
        if not self._nodeExists(self.border_gateway):
            emsg = "Border-gateway node %s does not exist." % (self.border_gateway)
            self.logger.error("[localhost] WeaveTunnelTest: %s" % (emsg))
            sys.exit(1)

        # Check if Weave Tunnel service node exists.
        if not self._nodeExists(self.service):
            emsg = "Service node %s does not exist." % (self.service)
            self.logger.error("[localhost] WeaveTunnelTest: %s" % (emsg))
            sys.exit(1)

        self.fabric_id = self.getFabricId()

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

        # Get the IPv4 address of the Service to connect to
        self.service_public_ip = self.getNodePublicIPv4Address(self.service)

        # Get the Weave ID for the Service node
        self.service_weave_id = self.getServiceWeaveID("Tunnel")

        # Get the Weave ID for the Border gateway node
        self.gateway_weave_id = self.getWeaveNodeID(self.border_gateway)
 
        # Get the Weave IPv6 ULA address of the Ser\vice node
        self.server_ula = self.getServiceWeaveIPAddress("Tunnel", self.service_weave_id)

        # Check if all unknowns were found

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

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

        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))
            sys.exit(1)

        if self.server_ula == None:
            emsg = "Could not find Weave ULA Address of the Service node."
            self.logger.error("[localhost] WeaveTunnel: %s" % (emsg))
            sys.exit(1)

    def __wait_for_gateway(self):
        self.wait_for_test_to_end(self.border_gateway, self.gateway_process_tag)

    def __stop_server_side(self):
        self.stop_weave_process(self.service, self.service_process_tag)

    def __process_results(self, client_output):
        # search for 'Passed' word
        pass_test = True

        for line in client_output.split("\n"):
            if "'FAILED'" in line or "'PASSED'" in line:
                tokens = line.split("'")
                for str in tokens:
                    if str.startswith('Test', 0, len(str)):
                        testName = str

                if "'FAILED'" in line:
                    print hred(testName + ":" + " FAILED ")
                    pass_test = False
                if "'PASSED'" in line:
                    print hgreen(testName + ":" + " PASSED ")


        return (pass_test, client_output)

    def __start_tunnel_test_server(self):
        cmd = self.getWeaveTunnelTestServerPath()
        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

        cmd = self.runAsRoot(cmd)
        self.start_weave_process(self.service, cmd, self.service_process_tag, sync_on_output=self.ready_to_service_events_str)

        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))
                sys.exit(1)

            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 __assign_tunnel_endpoint_ula_at_test_server(self):
        addr = self.getServiceWeaveIPAddress("Tunnel", self.service)

        options = happy.HappyNodeAddress.option()
        options["quiet"] = self.quiet
        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_test_tunnel_border_gateway_client(self):
        cmd = self.getWeaveTunnelTestBRPath()
        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

        cmd += " -S " + str(self.server_ula) + " --connect-to " + self.service_public_ip + " " + str(self.service_weave_id)
        cmd = self.runAsRoot(cmd)
        self.start_weave_process(self.border_gateway, cmd, self.gateway_process_tag, sync_on_output=self.ready_to_service_events_str)


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

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

        self.__start_tunnel_test_server()
        self.__assign_tunnel_endpoint_ula_at_test_server()

        self.__start_test_tunnel_border_gateway_client()

        self.__wait_for_gateway()
        
        gateway_output_value, gateway_output_data = \
            self.get_test_output(self.border_gateway, self.gateway_process_tag, True)
        gateway_strace_value, gateway_strace_data = \
            self.get_test_strace(self.border_gateway, self.gateway_process_tag, True)

        self.__stop_server_side()
        service_output_value, service_output_data = \
            self.get_test_output(self.service, self.service_process_tag, True)
        service_strace_value, service_strace_data = \
            self.get_test_strace(self.service, self.service_process_tag, True)

        status, results = self.__process_results(gateway_output_data)

        data = {}
        data["gateway_output"] = gateway_output_data
        data["gateway_strace"] = gateway_strace_data
        data["service_output"] = service_output_data
        data["service_strace"] = service_strace_data

        self.logger.debug("[localhost] WeaveTunnelTest: Done.")

        return ReturnMsg(status, data)