#!/usr/bin/env python


#
#    Copyright (c) 2015-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 WeavePing class that tests Weave Echo among Weave Nodes.
#

import os
import sys

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

from plugin.WeaveTest import WeaveTest


options = {"count": None,
           "udp": False,
           "tcp": False,
           "wrmp": False,
           "quiet": False,
           "no_service": False,
           "interval": None,
           "tap": None,
           "case": False,
           "case_shared": False,
           "timeout": None,
           "client_process_tag": "WEAVE-ECHO-CLIENT",
           "server_process_tag": "WEAVE-ECHO-SERVER",
           "endpoint": "Echo",
           "clients_info": [],
           "server_node_id": None,
           "strace": True,
           "case_cert_path": None,
           "case_key_path": None,
           "use_persistent_storage": True,
           "plaid_server_env": {},
           "plaid_client_env": {}
           }


def option():
    return options.copy()


class WeavePing(HappyNode, HappyNetwork, WeaveTest):
    """
    weave-ping [-h --help] [-q --quiet] [-o --origin <NAME>] [-s --server <NAME>]
           [-c --count <NUMBER>] [-u --udp] [-t --tcp] [-w --wrmp] [-i --interval <ms>] [-p --tap <TAP_INTERFACE>]
           [-C --case] [--case-shared] [-E --case_cert_path <path>] [-T --case_key_path <path>]
    command to test weave ping over UDP:
        $ weave-ping -o node01 -s node02 -u -i 100 -c 5

    command to test weave ping over TCP:
        $ weave-ping -o node01 -s node02 -t

    command to test weave ping over WRMP:
        $ weave-ping -o node01 -s node02 -w

    command to test weave ping over WRMP and CASE:
        $ weave-ping -o node01 -s node02 -w --case --case_cert_path path --case_key_path path

    command to test weave ping over WRMP with shared CASE session to the Nest Core Router:
        $ weave-ping -o node01 -s node02 -w --case-shared --case_cert_path path --case_key_path path

    return:
        0-100   percentage of the lost packets

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

    def __pre_check(self):
        # clear network info
        self.clients_info = []
        # Make sure that fabric was created
        if self.getFabricId() == None:
            emsg = "Weave Fabric has not been created yet."
            self.logger.error("[localhost] WeavePing: %s" % (emsg))
            sys.exit(1)

        if self.count != None and self.count.isdigit():
            self.count = int(float(self.count))
        else:
            self.count = 1

        for client in self.clients:
            client_node_id = None

            # Check if Weave Ping client node is given.
            if client == None:
                emsg = "Missing name or address of the Weave Ping client node."
                self.logger.error("[localhost] WeavePing: %s" % (emsg))
                sys.exit(1)

            # Check if Weave Ping client node exists.
            if self._nodeExists(client):
                client_node_id = client

            # Check if client is provided in a form of IP address
            if self.isIpAddress(client):
                client_node_id = self.getNodeIdFromAddress(client)

            if client_node_id == None:
                emsg = "Unknown identity of the client node."
                self.logger.error("[localhost] WeavePing: %s" % (emsg))
                sys.exit(1)

            if self.getNodeType(client_node_id) == "service":
                client_ip = self.getServiceWeaveIPAddress(self.endpoint, client_node_id)
                client_weave_id = self.getServiceWeaveID(self.endpoint, client_node_id)
            else:
                client_ip = self.getNodeWeaveIPAddress(client_node_id)
                client_weave_id = self.getWeaveNodeID(client_node_id)

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

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

            self.clients_info.append({'client': client, 'client_node_id': client_node_id, 'client_ip': client_ip,
                          'client_weave_id': client_weave_id, 'client_process_tag': client + "_" + self.client_process_tag + client})


        # Check if Weave Ping server node is given.
        if self.server == None:
            emsg = "Missing name or address of the Weave Ping server node."
            self.logger.error("[localhost] WeavePing: %s" % (emsg))
            sys.exit(1)

        # Check if Weave Ping server node exists.
        if self._nodeExists(self.server):
            self.server_node_id = self.server

        # Check if server is provided in a form of IP address
        if self.isIpAddress(self.server):
            self.no_service = True
            self.server_ip = self.server
            self.server_weave_id = self.IPv6toWeaveId(self.server)
        elif self.isDomainName(self.server) or self.server == "service":
            self.no_service = True
            self.server_ip = self.getServiceWeaveIPAddress(self.endpoint)
            self.server_weave_id = self.IPv6toWeaveId(self.server_ip)
        else:
            # Check if server is a true clound service instance
            if self.getNodeType(self.server) == self.node_type_service:
                self.no_service = True

        if not self.no_service and self.server_node_id == None:
            emsg = "Unknown identity of the server node."
            self.logger.error("[localhost] WeavePing: %s" % (emsg))
            sys.exit(1)

        if self.getNodeType(self.server_node_id) == "service":
            self.server_ip = self.getServiceWeaveIPAddress(self.endpoint, self.server_node_id)
            self.server_weave_id = self.getServiceWeaveID(self.endpoint, self.server_node_id)
        else:
            if not self.no_service:
                self.server_ip = self.getNodeWeaveIPAddress(self.server_node_id)
                self.server_weave_id = self.getWeaveNodeID(self.server_node_id)

        # Check if all unknowns were found

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

        if not self.no_service and self.server_weave_id == None:
            emsg = "Could not find Weave node ID of the server node."
            self.logger.error("[localhost] WeavePing: %s" % (emsg))
            sys.exit(1)


    def __process_results(self, client_info, output):
        # search for '%' e.g.  1/1(100.00%)
        loss_percentage = None

        for line in output.split("\n"):
            if not "%" in line:
                continue

            for token in line.split():
                if "%" in token:
                    loss_percentage = token.strip().split("(")[1]
                    loss_percentage = loss_percentage.translate(None, "()%")

        if loss_percentage == None:
            # hmmm, we haven't found our line
            loss_percentage = 100
        else:
            loss_percentage = float(loss_percentage)
            loss_percentage = 100 - loss_percentage

        if self.quiet == False:
            print "weave-ping from node %s (%s) to node %s (%s) : " % \
                (client_info['client_node_id'], client_info['client_ip'],
                 self.server_node_id, self.server_ip),

            if loss_percentage == 0:
                print hgreen("%f%% packet loss" % (loss_percentage))
            else:
                print hred("%f%% packet loss" % (loss_percentage))

        return  loss_percentage # indicate the loss for each client
    

    def __start_server_side(self):
        if self.no_service:
            return

        cmd = self.getWeavePingPath()
        if not cmd:
            return

        if self.tcp:
            cmd += " --tcp"
        elif self.udp:
            # default is UDP
            cmd += " --udp"
        elif self.wrmp:
            cmd += " --wrmp"

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

        self.start_simple_weave_server(cmd, self.server_ip,
             self.server_node_id, self.server_process_tag, use_persistent_storage = self.use_persistent_storage, env=self.plaid_server_env)


    def __start_client_side(self, client_info):
        cmd = self.getWeavePingPath()
        if not cmd:
            return

        if self.tcp:
            cmd += " --tcp"
        elif self.udp:
            # default is UDP
            cmd += " --udp"
        elif self.wrmp:
            cmd += " --wrmp"

        if self.interval != None:
            cmd += " --interval " + self.interval
    
        cmd += " --count " + str(self.count)

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

        if self.case:
            if self.case_shared:
                cmd += " --case-shared"
            else:
                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'], client_info["client_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'], client_info["client_weave_id"].upper() + '-key.weave-b64')
                cmd += ' --node-cert ' + self.cert_file + ' --node-key ' + self.key_file

        self.start_simple_weave_client(cmd, client_info['client_ip'],
            self.server_ip, self.server_weave_id,
            client_info['client_node_id'], client_info['client_process_tag'], use_persistent_storage=self.use_persistent_storage, env=self.plaid_client_env)


    def __wait_for_client(self, client_info):
        self.wait_for_test_to_end(client_info["client_node_id"], client_info["client_process_tag"], timeout=self.timeout)


    def __stop_server_side(self):
        if self.no_service:
            return

        self.stop_weave_process(self.server_node_id, self.server_process_tag)


    def run(self):
        all_data = []
        self.logger.debug("[localhost] WeavePing: Run.")

        self.__pre_check()

        self.__start_server_side()

        emsg = "WeavePing %s should be running." % (self.server_process_tag)
        self.logger.debug("[%s] WeavePing: %s" % (self.server_node_id, emsg))

        for client_info in self.clients_info:
            self.__start_client_side(client_info)
        for client_info in self.clients_info:
            self.__wait_for_client(client_info)
        for client_info in self.clients_info:
            client_output_value, client_output_data = \
                self.get_test_output(client_info['client_node_id'], client_info['client_process_tag'], True)
            client_strace_value, client_strace_data = \
                self.get_test_strace(client_info['client_node_id'], client_info['client_process_tag'], True)

            if self.no_service:
                server_output_data = ""
                server_strace_data = ""
            else:
                self.__stop_server_side()
                server_output_value, server_output_data = \
                    self.get_test_output(self.server_node_id, self.server_process_tag, True)
                server_strace_value, server_strace_data = \
                    self.get_test_strace(self.server_node_id, self.server_process_tag, True)

            loss_percentage = self.__process_results(client_info, client_output_data)

            data = {}
            data.update(client_info)
            data["client_output"] = client_output_data
            data["server_output"] = server_output_data
            if self.strace:
                data["client_strace"] = client_strace_data
                data["server_strace"] = server_strace_data
            all_data.append(data)

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

        return ReturnMsg(loss_percentage, all_data)