#!/usr/bin/env python

#
#    Copyright (c) 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
#       Implementes WeaveWdmNext Next class that tests Weave WDM Next among Weave Nodes.
#

import os
import re
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
import plugin.WeaveUtilities as WeaveUtilities
import plugins.plaid.Plaid as Plaid

options = { "clients": None,
            "server": None,
            "quiet": False,
            "tap": None,
            "wdm_option": None,
            "strace": True,
            "plaid": "auto",
            "timeout": None,
            "enable_client_stop": True,
            "save_client_perf": False,
            "client_faults": None,
            "server_faults": None,
            "client_event_generator": False,
            "client_inter_event_period": None,
            "enable_server_stop": False,
            "save_server_perf": False,
            "server_event_generator": None,
            "server_inter_event_period": None,
            "test_server_iterations": 1,
            "wdm_client_liveness_check_period": None,
            "wdm_server_liveness_check_period": None,
            "case": False,
            "enable_retry": False,
            "case_cert_path": None,
            "enable_mock_event_timestamp_initial_counter": False,
            "case_key_path": None,
            "group_enc": False,
            "group_enc_key_id": None,
            "use_persistent_storage": True
          }


def option():
    return options.copy()


class WeaveWdmNext(HappyNode, HappyNetwork, WeaveTest):
    """
     Runs a WDM test  between a client and a server. The following options are supported.

     test_client_case, test_server_case:

       Maps to --test-case
       Controls which traits are published and subscribed to.
       The same value needs to be specified for both, for the subscriptions to work


     total_client_count, total_server_count:

       Maps to --total-count
       The number of times the node will mutate the trait instance per iteration;
       The frequency of the mutations is controlled by timer_server_period and timer_client_period
       Note that the server sends a custom command at the same time it mutates the trait instance.
       The command type alternates between 1 and 2. Command 1 is served immediately by the client;
       Command 2 is executed with a delay (the client sends a kMsgType_InProgress).


     timer_server_period, timer_client_period:

       Maps to --timer-period
       The period of the trait instance mutations.


     final_client_status, final_server_status:

       Maps to --final-status, with the following values:
       0(client cancel), 1(publisher cancel), 2(client abort), 3(Publisher abort), 4(Idle)
       This parameter controls what ends the test iteration. Both the client and the server have
       a subscription client and a subscription handler (publisher). The node will terminate the
       iteration with a Cancel or Abort, after either its publisher or its client have performed
       all mutations and have become Idle.
       A value of 4(Idle) means that the node will just wait for the other node to act.


     test_client_iterations:

       Maps to --test-iterations on the client node
       The number of times the test sequence (establish subscriptions, mutate N times,
       cancel or abort) should be repeated.


     test_server_iterations:

       Maps to --test-iterations on the server node
       This is 1 by default and our tests never change it, since the tests are driven from
       the client side and the server node is passive.


     test_client_delay, test_server_delay:

       Maps to --test-delay.
       The nodes will sleep for the given number of milliseconds between iterations
       Currently, this needs to be more than 2 seconds if the server is sending commands, since the
       client executes command type 2 with a delay of 2 seconds.


     client_clear_state_between_iterations, server_clear_state_between_iterations:

       Maps to --clear-state-between-iterations
       Resets the state of the data sink after each iteration


     enable_client_stop, enable_server_stop:

       Maps to --enable-stop
       Controls whether the process will exit the iteration or not at the end of the iteration
       This is always enabled on the client, and disabled on the server; the caller should
       not need to change these values.


     client_event_generator, server_event_generator:

       Maps to --event-generator
       Controls the event generator (None | Debug | Livenesss | Security | Telemetry | TestTrait)
       running in the node's background.
       See the option help string in TestWdmNext.cpp. The frequency at which events are generated
       is controlled by client_inter_event_period and server_inter_event_period


     client_inter_event_period, server_inter_event_period:

       Maps to --inter-event-period
       The period used by the event generator in milliseconds
    """

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

        remove_keys = ["test_server_case", "total_server_count", "final_server_status", "timer_server_period",
                       "enable_server_stop", "test_server_iterations", "test_server_delay", "enable_server_flip",
                       "save_server_perf", "server_event_generator", "server_inter_event_period",
                       "wdm_server_liveness_check_period"]

        if opts['server'] == 'service':
            for i in remove_keys:
                if i in opts:
                    del opts[i]

        self.__dict__.update(opts)

        self.no_service = False

        self.server_process_tag = "WEAVE_WDM_SERVER" + (opts["test_tag"] if "test_tag" in opts else "")
        self.client_process_tag = "WEAVE_WDM_CLIENT" + (opts["test_tag"] if "test_tag" in opts else "")
        self.plaid_server_process_tag = "PLAID_SERVER" + (opts["test_tag"] if "test_tag" in opts else "")

        self.client_node_id = None
        self.server_node_id = None

        self.clients_info = []

        self.wdm_client_option = None
        self.wdm_server_option = None

        plaid_opts = Plaid.default_options()
        plaid_opts["quiet"] = self.quiet
        self.plaid_server_node_id = "node03"
        plaid_opts["server_node_id"] = self.plaid_server_node_id
        plaid_opts["num_clients"] = 2
        plaid_opts["server_ip_address"] = self.getNodeWeaveIPAddress(self.plaid_server_node_id)
        plaid_opts["strace"] = self.strace
        self.plaid = Plaid.Plaid(plaid_opts)

        self.use_plaid = opts["plaid"]
        if opts["plaid"] == "auto":
            if self.server == "service":
                # can't use plaid when talking to an external service
                self.use_plaid = False
            else:
                self.use_plaid = self.plaid.isPlaidConfigured()


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

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

        # Check if WeaveWdmNext server node exists.
        if self._nodeExists(self.server):
            self.server_node_id = self.server
            self.server_process_tag = self.server_node_id + "_" + self.server_process_tag

        # 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("DataManagement")
            self.server_weave_id = self.IPv6toWeaveId(self.server_ip)
        else:
            # Check if server is a true cloud 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 is None:
            emsg = "Unknown identity of the server node."
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if self.getNodeType(self.server_node_id) == "service":
            self.server_ip = self.getServiceWeaveIPAddress("WeaveWdmNext", self.server_node_id)
            self.server_weave_id = self.getServiceWeaveID("WeaveWdmNext", 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)

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

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

        for client in self.clients:
            client_node_id = None
            client_ip = None
            client_weave_id = None
            # Check if Weave Wdm Next client node is given.
            if client == None:
                emsg = "Missing name or address of the WeaveWdmNext client node."
                self.logger.error("[localhost] WeaveWdmNext: %s" % (emsg))
                sys.exit(1)

            # Check if WeaveWdmNext 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 is None:
                emsg = "Unknown identity of the client node."
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

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

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

            if client_weave_id is None:
                emsg = "Could not find Weave node ID of the client node."
                self.logger.error("[localhost] WeaveWdmNext: %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})

        if self.wdm_option == "view":
            self.wdm_client_option = " --wdm-simple-view-client"
            self.wdm_server_option = " --wdm-simple-view-server"
            print "view disabled"
            sys.exit(1)
        elif self.wdm_option == "one_way_subscribe":
            self.wdm_client_option = " --wdm-one-way-sub-client"
            self.wdm_server_option = " --wdm-one-way-sub-publisher"
        elif self.wdm_option == "mutual_subscribe":
            self.wdm_client_option = " --wdm-init-mutual-sub"
            self.wdm_server_option = " --wdm-resp-mutual-sub"
        else:
            emsg = "NOT SUPPORTED WDM OPTION"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if self.test_client_case not in [1, 2, 3, 4, 5]:
            emsg = "TestWdmNext only support test case 1, 2, 3, 4 and 5 in in client side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if not (isinstance(self.total_client_count, int) and self.total_client_count >= -1):
            emsg = "The number of notifications should not less than -1 in client side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if self.final_client_status not in [0, 1, 2, 3, 4]:
            emsg = "TestWdmNext only support final status, 0(client cancel), 1(publisher cancel), 2(client abort)," \
                   " 3(Publisher abort), 4(Idle) in client side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if not (isinstance(self.timer_client_period, int) and self.timer_client_period >= 0):
            emsg = "The period of notification timer should not less than 0 in client side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if not isinstance(self.enable_client_stop, bool):
            emsg = "TestWdmNext needs to specify if stopping test finally in client side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if not (isinstance(self.test_client_iterations, int) and self.test_client_iterations >= 1):
            emsg = "TestWdmNext needs at least one iteration in client side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if not (isinstance(self.test_client_delay, int) and self.test_client_delay >= 0):
            emsg = "The test delay between iterations should not less than 0 in client side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if not isinstance(self.save_client_perf, bool):
            emsg = "TestWdmNext needs to save per date in file finally in server side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)

        if self.enable_client_flip not in [0, 1]:
            emsg = "TestWdmNext only support flip 0 and 1 in server side"
            self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
            sys.exit(1)
        if self.server != "service":
            if self.test_server_case not in [1, 2, 3, 4, 5]:
                emsg = "TestWdmNext only support test case 1, 2, 3, 4 and 5 in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if not (isinstance(self.total_server_count, int) and self.total_server_count >= -1):
                emsg = "The number of notifications should not less than -1 in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if self.final_server_status not in [0, 1, 2, 3, 4]:
                emsg = "TestWdmNext only support final status, 0(client cancel), 1(publisher cancel), 2(client abort)," \
                       " 3(Publisher abort), 4(Idle) in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if not (isinstance(self.timer_server_period, int) and self.timer_server_period >= 0):
                emsg = "The period of notification timer should not less than 0 in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if not isinstance(self.enable_server_stop, bool):
                emsg = "TestWdmNext needs to specify if stopping test finally in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if not (isinstance(self.test_server_iterations, int) and self.test_server_iterations >= 1):
                emsg = "TestWdmNext needs at least one iteration in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if not (isinstance(self.test_server_delay, int) and self.test_server_delay >= 0):
                emsg = "The test delay between iterations should not less than 0 in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if not isinstance(self.save_server_perf, bool):
                emsg = "TestWdmNext needs to save per date in file finally in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if self.enable_server_flip not in [0, 1]:
                emsg = "TestWdmNext only support flip 0 and 1 in server side"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if self.server_event_generator is not None and self.server_event_generator not in ["Debug", "Livenesss", "Security"]:
                emsg = "TestWdmNext only support Debug, Liveness, and Security event"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

            if self.server_inter_event_period is not None and int(self.server_inter_event_period) < 0:
                emsg = "TestWdmNext event generation's period shoud be larger than 0"
                self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
                sys.exit(1)

    def __process_results(self, client_output, server_output, client_info):
        kevents = re.findall(r"WEAVE:.+kEvent_\w+", client_output)
        smoke_check = False
        client_parser_error = None
        client_leak_detected = None
        server_parser_error = None
        server_leak_detected = None
        result = {}
        client_parser_error, client_leak_detected = WeaveUtilities.scan_for_leaks_and_parser_errors(client_output)
        result["no_client_parser_error"] = not client_parser_error
        result["no_client_leak_detected"] = not client_leak_detected
        if server_output is not "":
            server_parser_error, server_leak_detected = WeaveUtilities.scan_for_leaks_and_parser_errors(server_output)
            result["no_server_parser_error"] = not client_parser_error
            result["no_server_leak_detected"] = not server_leak_detected
        if self.wdm_option == "view":
            if any("kEvent_ViewResponseReceived" in s for s in kevents) and \
                            kevents[-1] == "kEvent_ViewResponseConsumed":
                smoke_check = True
            else:
                smoke_check = False
        elif self.wdm_option == "one_way_subscribe":
            if any("Client->kEvent_OnSubscriptionEstablished" in s for s in kevents) \
                    and "Closing endpoints" in client_output:
                smoke_check = True
            else:
                smoke_check = False
        elif self.wdm_option == "mutual_subscribe":
            if any("Publisher->kEvent_OnSubscriptionEstablished" in s for s in kevents) \
                    and "Closing endpoints" in client_output:
                smoke_check = True
            else:
                smoke_check = False
        result["smoke_check"] = smoke_check

        if self.quiet is False:
            print "weave-wdm-next %s from node %s (%s) to node %s (%s) : "\
                  % (self.wdm_option, client_info["client_node_id"], client_info["client_ip"], self.server_node_id, self.server_ip)
            if smoke_check is True:
                for kevent in kevents:
                    print hgreen(kevent)
                print hgreen("weave-wdm-next %s success" % self.wdm_option)
            else:
                for kevent in kevents:
                    print hred(kevent)
                print hred("weave-wdm-next %s failure" % self.wdm_option)

            if client_parser_error is True:
                print hred("client parser error")
            if client_leak_detected is True:
                print hred("client_resource leak detected")
            if server_parser_error is True:
                print hred("server parser error")
            if server_leak_detected is True:
                print hred("server resource leak detected")

        return result


    def wdm_next_checksum_check_process(self, log):
        """Pull out checksum value list for each trait object sent or received."""
        checksum_list= re.findall("Checksum is (\w+)", log)
        return checksum_list


    def wdm_next_client_event_sequence_process(self, log):
        """Pull out the number of events sent in a notification.  Only notifications with non-zero events are reported"""
        success = True
        client_event_list= re.findall("Fetched (\d+) events", log)
        client_event_process_list = [int(event) for event in client_event_list if int(event) > 0]
        return {"client_event_list":client_event_process_list, "length": len(client_event_process_list), "success": success}


    def wdm_next_publisher_event_sequence_process(self, log):
        """Pull out the number of events received in a notification. All notifications with EventList element are reported.  It would be considered an error to receive an empty EventList"""
        publisher_event_list = re.finditer("WEAVE:DMG: \tEventList =", log)
        success = True
        event_list_len = []
        for eventListMarker in publisher_event_list:
            startEventList = eventListMarker.end()
            endEventListMarker = re.search(".*WEAVE:DMG: \t],.*", log[startEventList:])
            if endEventListMarker:
                endEventList = endEventListMarker.end()
                event_list_len.append(len(re.findall("WEAVE:DMG: \t\t{", log[startEventList:(startEventList+endEventList)])))
            else:
                success = False
        return {"publisher_event_list":event_list_len, "length": len(event_list_len), "success": success}

    def __start_plaid_server(self):

        self.plaid.startPlaidServerProcess()

        emsg = "plaid-server should be running."
        self.logger.debug("[%s] WeaveWdmNext: %s" % (self.plaid_server_node_id, emsg))

    def __start_server_side(self):
        if self.no_service:
            return
        cmd = self.getWeaveWdmNextPath()
        if not cmd:
            return
        self.server_id = self.server_weave_id
        cmd += self.wdm_server_option

        if self.enable_server_stop is True:
            cmd += " --enable-stop "

        if self.save_server_perf is True:
            cmd += " --save-perf"

        if self.wdm_server_liveness_check_period is not None:
            cmd += " --wdm-liveness-check-period " + str(self.wdm_server_liveness_check_period)

        cmd += " --test-case " + str(self.test_server_case)
        cmd += " --total-count " + str(self.total_server_count)
        cmd += " --final-status " + str(self.final_server_status)
        cmd += " --timer-period " + str(self.timer_server_period)
        cmd += " --test-iterations " + str(self.test_server_iterations)
        cmd += " --test-delay " + str(self.test_server_delay)
        cmd += " --enable-flip " + str(self.enable_server_flip)
        if self.server_faults != None:
            cmd += " --faults " + self.server_faults

        if self.__dict__.get("server_clear_state_between_iterations", False):
            cmd += " --clear-state-between-iterations"

        if self.server_event_generator is not None:
            cmd += " --event-generator " + str(self.server_event_generator)

        if self.server_inter_event_period is not None:
            cmd += " --inter-event-period " + str(self.server_inter_event_period)

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

        custom_env = {}
        if self.use_plaid:
            custom_env = self.plaid.getPlaidClientLibEnv(self.server_node_id)

        self.start_simple_weave_server(cmd, self.server_ip, self.server_node_id, self.server_process_tag, listen=False, strace=self.strace, env=custom_env, use_persistent_storage=self.use_persistent_storage)


    def __start_client_side(self, client_info):
        cmd = self.getWeaveWdmNextPath()
        if not cmd:
            return
        cmd += self.wdm_client_option
        cmd += " --wdm-publisher " + self.server_weave_id

        if self.enable_client_stop is True:
            cmd += " --enable-stop "

        if self.save_client_perf is True:
            cmd += " --save-perf"

        if self.wdm_client_liveness_check_period is not None:
            cmd += " --wdm-liveness-check-period " + str(self.wdm_client_liveness_check_period)

        cmd += " --enable-dictionary-test " if self.enable_client_dictionary_test else ""

        cmd += " --test-case " + str(self.test_client_case)
        cmd += " --total-count " + str(self.total_client_count)
        cmd += " --final-status " + str(self.final_client_status)
        cmd += " --timer-period " + str(self.timer_client_period)
        cmd += " --test-iterations " + str(self.test_client_iterations)
        cmd += " --test-delay " + str(self.test_client_delay)
        cmd += " --enable-flip " + str(self.enable_client_flip)

        if self.__dict__.get("client_clear_state_between_iterations", False):
            cmd += " --clear-state-between-iterations"

        if self.client_faults != None:
            cmd += " --faults " + self.client_faults

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

        if self.server == "service":
            node_id = client_info["client_weave_id"]
            fabric_id = self.getFabricId()
            client_info["client_ip"] = None
            cmd += " --wdm-subnet 5 --node-id=%s --fabric-id %s " % (node_id, fabric_id)

        if self.client_event_generator is not None:
            cmd += " --event-generator " + str(self.client_event_generator)

        if self.client_inter_event_period is not None:
            cmd += " --inter-event-period " + str(self.client_inter_event_period)

        if self.case:
            self.cert_file = self.case_cert_path if self.case_cert_path else os.path.join(self.main_conf["log_directory"], node_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"], node_id.upper() + "-key.weave-b64")
            cmd += " --case " + " --node-cert " + self.cert_file + " --node-key " + self.key_file

        if self.group_enc:
            cmd += ' --group-enc ' + ' --group-enc-key-id ' + self.group_enc_key_id

        if self.enable_retry:
            cmd += " --enable-retry"

        if self.enable_mock_event_timestamp_initial_counter:
            cmd += " --enable-mock-event-timestamp-initial-counter"

        custom_env = {}
        if self.use_plaid:
            custom_env = self.plaid.getPlaidClientLibEnv(client_info["client_node_id"])

        self.start_simple_weave_client(cmd, client_info["client_ip"], None, None, client_info["client_node_id"],
                                       client_info["client_process_tag"], strace=self.strace, env=custom_env, use_persistent_storage=self.use_persistent_storage)


    def __wait_for_client(self, client_info):
        self.wait_for_test_to_end(client_info["client_node_id"], client_info["client_process_tag"], quiet=False, 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 __stop_client_side(self):
        if self.no_service:
            return

        self.stop_weave_process(self.client_node_id, self.client_process_tag)


    def __stop_plaid_server(self):
        self.plaid.stopPlaidServerProcess()


    def run_client_test(self):
        all_data = []
        success = True
        self.__pre_check()

        if self.use_plaid:
            self.__start_plaid_server()

        self.__start_server_side()

        emsg = "WeaveWdmNext %s should be running." % self.server_process_tag
        self.logger.debug("[%s] WeaveWdmNext: %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)
            if self.strace:
                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()
                if self.use_plaid:
                    self.__stop_plaid_server()
                server_output_value, server_output_data = \
                    self.get_test_output(self.server_node_id, self.server_process_tag, True)
                if self.strace:
                    server_strace_value, server_strace_data = \
                            self.get_test_strace(self.server_node_id, self.server_process_tag, True)

            success_dic = self.__process_results(client_output_data, server_output_data, client_info)

            smoke_check_ghost = success_dic["smoke_check"]
            if self.client_faults or self.server_faults:
                success_dic["smoke_check"] = True
            success = reduce(lambda x, y: x and y, success_dic.values())
            success_dic["smoke_check"] = smoke_check_ghost

            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
            data["success_dic"] = success_dic
            all_data.append(data)

        return ReturnMsg(success, all_data)

    def run(self):
        return self.run_client_test()