| #!/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 WeaveBDX class that tests Weave BDX among Weave Nodes. |
| # |
| |
| import os |
| import sys |
| import time |
| |
| 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 = {} |
| options["quiet"] = False |
| options["server"] = None |
| options["client"] = None |
| options["tmp"] = None |
| options["receive"] = None |
| options["download"] = None |
| options["upload"] = None |
| options["offset"] = None |
| options["length"] = None |
| options["tap"] = None |
| options["server_version"] = 1 |
| options["client_version"] = 1 |
| options["client_faults"] = None |
| options["server_faults"] = None |
| options["strace"] = True |
| options["test_tag"] = "" |
| options["iterations"] = 1 |
| options["plaid"] = False |
| |
| |
| def option(): |
| return options.copy() |
| |
| |
| class WeaveBDX(HappyNode, HappyNetwork, WeaveTest): |
| """ |
| weave-bdx [-h --help] [-q --quiet] [-s --server <NAME>] [-c --client <NAME>] |
| [-t --tmp <SERVER_TMP_PATH>] [-r --receive <DESTINATION_PATH>] |
| [-u --upload <SOURCE_PATH>] [-d --download <SOURCE_PATH>] |
| [-o --offset <SIZE>] [-l --length <SIZE>] [-p --tap <TAP_INTERFACE>] |
| [-S --server-version <bdx_version>] [-C --client-version <bdx_version>] |
| |
| |
| commands to test bdx-v0: |
| $ weave-bdx -s node01 -c node02 -S 0 -C 0 --upload /client_files/test_file.txt --tmp /server/tmp --receive /server_files |
| Sends /client_files/test_file.txt from node02 to folder /server_files at node01. |
| |
| $ weave-bdx -s node01 -c node02 -S 0 -C 0 --download /server_files/test_file.txt --tmp /server/tmp --receive /client_files |
| Receives /server_files/test_file.txt from node01 at /client_files of node02. |
| |
| commands to test bdx-v1: |
| $ weave-bdx -s node01 -c node02 -S 1 -C 1 --upload /client_files/test_file.txt --tmp /server/tmp --receive /server_files |
| Sends /client_files/test_file.txt from node02 to folder /server_files at node01. |
| |
| $ weave-bdx -s node01 -c node02 -S 1 -C 1 --download /server_files/test_file.txt --tmp /server/tmp --receive /client_files |
| Receives /server_files/test_file.txt from node01 at /client_files of node02. |
| |
| commands to test bdx-v0 and bdx-v1 interop: |
| $ weave-bdx -s node01 -c node02 -S 0 -C 1 --upload /client_files/test_file.txt --tmp /server/tmp --receive /server_files |
| Sends /client_files/test_file.txt from node02 to folder /server_files at node01. |
| |
| $ weave-bdx -s node01 -c node02 -S 0 -C 1 --download /server_files/test_file.txt --tmp /server/tmp --receive /client_files |
| Receives /server_files/test_file.txt from node01 at /client_files of node02. |
| |
| $ weave-bdx -s node01 -c node02 -S 1 -C 0 --upload /client_files/test_file.txt --tmp /server/tmp --receive /server_files |
| Sends /client_files/test_file.txt from node02 to folder /server_files at node01. |
| |
| $ weave-bdx -s node01 -c node02 -S 1 -C 0 --download /server_files/test_file.txt --tmp /server/tmp --receive /client_files |
| Receives /server_files/test_file.txt from node01 at /client_files of node02. |
| |
| |
| Note: |
| special the BDX server and client version with '-S/-C' option, and BDX-v1 would be the default version |
| |
| return: |
| 0 success |
| 1 failure |
| |
| """ |
| def __init__(self, opts = options): |
| HappyNode.__init__(self) |
| HappyNetwork.__init__(self) |
| WeaveTest.__init__(self) |
| |
| self.quiet = opts["quiet"] |
| self.client = opts["client"] |
| self.server = opts["server"] |
| self.tmp = opts["tmp"] |
| self.download = opts["download"] |
| self.upload = opts["upload"] |
| self.receive = opts["receive"] |
| self.offset = opts["offset"] |
| self.length = opts["length"] |
| self.tap = opts["tap"] |
| self.server_version = opts["server_version"] |
| self.client_version = opts["client_version"] |
| self.server_faults = opts["server_faults"] |
| self.client_faults = opts["client_faults"] |
| self.iterations = opts["iterations"] |
| |
| self.server_process_tag = "WEAVE-BDX-SERVER" + opts["test_tag"] |
| self.client_process_tag = "WEAVE-BDX-CLIENT" + opts["test_tag"] |
| |
| self.client_node_id = None |
| self.server_node_id = None |
| |
| self.strace = opts["strace"] |
| |
| 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): |
| # Check if Weave BDX client node is given. |
| if self.client == None: |
| emsg = "Missing name or address of the Weave BDX client node." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| # Check if Weave BDX server node is given. |
| if self.server == None: |
| emsg = "Missing name or address of the Weave BDX server node." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| # Check if Weave BDX server version is correct. |
| if self.server_version != 0 and self.server_version != 1: |
| emsg = "BDX server version is not correct." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| # Check if Weave BDX client version is correct. |
| if self.client_version != 0 and self.client_version != 1: |
| emsg = "BDX client version is not correct." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| # Make sure that fabric was created |
| if self.getFabricId() == None: |
| emsg = "Weave Fabric has not been created yet." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| # Check if Weave BDX client node exists. |
| if self._nodeExists(self.client): |
| self.client_node_id = self.client |
| |
| # Check if Weave BDX server node exists. |
| if self._nodeExists(self.server): |
| self.server_node_id = self.server |
| |
| # Check if client is provided in a form of IP address |
| if self.isIpAddress(self.client): |
| self.client_node_id = self.getNodeIdFromAddress(self.client) |
| |
| # Check if server is provided in a form of IP address |
| if self.isIpAddress(self.server): |
| self.server_node_id = self.getNodeIdFromAddress(self.server) |
| elif self.server == "service": |
| if self.download is not None: |
| self.server_ip = self.getServiceWeaveIPAddress("FileDownload") |
| elif self.upload is not None: |
| self.server_ip = self.getServiceWeaveIPAddress("LogUpload") |
| self.server_weave_id = self.IPv6toWeaveId(self.server_ip) |
| self.server_node_id = "service" |
| |
| if self.client_node_id == None: |
| emsg = "Unknown identity of the client node." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if self.server_node_id == None: |
| emsg = "Unknown identity of the server node." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| self.client_ip = self.getNodeWeaveIPAddress(self.client_node_id) |
| self.client_weave_id = self.getWeaveNodeID(self.client_node_id) |
| if self.server is not "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.client_ip == None: |
| emsg = "Could not find IP address of the client node." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if self.server_ip == None: |
| emsg = "Could not find IP address of the server node." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if self.client_weave_id == None: |
| emsg = "Could not find Weave node ID of the client node." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if self.server_weave_id == None: |
| emsg = "Could not find Weave node ID of the server node." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| # Check tmp, upload, download, receive paths |
| if self.server is not "service": |
| if self.tmp == None: |
| emsg = "Missing path to a temporaty directory that is used by BDX server." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if not os.path.isdir(self.tmp): |
| emsg = "The server BDX temp %s is not a directory." % (self.tmp) |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if self.receive == None: |
| emsg = "Missing path to receiving directory." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if not os.path.isdir(self.receive): |
| emsg = "The receiving path %s is not a directory." % (self.receive) |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if (self.download == None and self.upload == None) or \ |
| (self.download != None and self.upload != None): |
| emsg = "Either download or upload path must be specified." |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if self.offset != None: |
| self.offset = str(self.offset) |
| if not self.offset.isdigit(): |
| emsg = "File offset must be a number, not %s." % (self.offset) |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| if self.length != None: |
| self.length = str(self.length) |
| if not self.length.isdigit(): |
| emsg = "File length must be a number, not %s." % (self.length) |
| self.logger.error("[localhost] WeaveBDX: %s" % (emsg)) |
| sys.exit(1) |
| |
| 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.server_version == 0: |
| cmd = self.getWeaveBDXv0ServerPath() |
| if not cmd: |
| return; |
| |
| cmd += " -a " + self.server_ip |
| |
| if self.download != None: |
| cmd += " -r " + self.download |
| else: |
| cmd += " -R " + self.receive |
| |
| else: |
| cmd = self.getWeaveBDXServerPath() |
| if not cmd: |
| return |
| |
| cmd += " -a " + self.server_ip \ |
| + " -T " + self.tmp |
| |
| if self.download != None: |
| # Client downloads file specified in self.download |
| cmd += " -R " + os.path.dirname(self.download) |
| else: |
| cmd += " -R " + self.receive |
| |
| if self.tap: |
| cmd += " --interface " + self.tap |
| |
| if self.server_faults != None: |
| cmd += " --faults " + self.server_faults |
| |
| if self.server_faults or self.client_faults: |
| cmd += " --extra-cleanup-time 10000" |
| |
| custom_env = {} |
| if self.use_plaid: |
| custom_env = self.plaid.getPlaidClientLibEnv(self.server_node_id) |
| |
| self.start_weave_process(self.server_node_id, cmd, self.server_process_tag, strace=self.strace, env=custom_env, sync_on_output="Weave Node ready to service events") |
| |
| |
| def __start_client_side(self): |
| if self.client_version == 0: |
| cmd = self.getWeaveBDXv0ClientPath() |
| if not cmd: |
| return; |
| |
| cmd += " " + self.server_weave_id + "@" + self.server_ip \ |
| + " -a " + self.client_ip + " -R " + self.receive + " -T" \ |
| + " --iterations " + str(self.iterations) |
| |
| if self.download != None: |
| if self.server_version == 1: |
| cmd += " -r" + " file://" + self.download |
| else: |
| cmd += " -r " + self.download |
| else: |
| cmd += " -r " + self.upload + " -p" |
| |
| else: |
| cmd = self.getWeaveBDXClientPath() |
| if not cmd: |
| return |
| if self.server is not "service": |
| cmd += " " + self.server_weave_id + "@" + self.server_ip \ |
| + " -a " + self.client_ip + " -T" |
| else: |
| cmd += " " + self.server_weave_id + "@" + self.server_ip \ |
| + " -a " + self.client_ip |
| |
| cmd += " --iterations " + str(self.iterations) |
| |
| if self.download != None: |
| if self.server_version == 1: |
| if self.server is not "service": |
| cmd += " -r" + " file://" + self.download + " -R " + self.receive + " -u " |
| else: |
| cmd +=" -r" + " weave-bdx://" + self.download + " -R " + self.receive + " -u " |
| else: |
| cmd += " -r " + self.download + " -R " + self.receive |
| else: |
| if self.server is not "service": |
| cmd += " -r " + self.upload + " -p" |
| else: |
| cmd += " -r " + self.upload + " -p -u" |
| |
| if self.offset != None: |
| cmd += " -s " + self.offset |
| |
| if self.length != None: |
| cmd += " -l " + self.length |
| |
| if self.tap: |
| cmd += " --interface " + self.tap |
| |
| if self.client_faults != None: |
| cmd += " --faults " + self.client_faults |
| |
| if self.server_faults or self.client_faults: |
| cmd += " --extra-cleanup-time 10000" |
| |
| |
| custom_env = {} |
| if self.use_plaid: |
| custom_env = self.plaid.getPlaidClientLibEnv(self.client_node_id) |
| |
| self.start_weave_process(self.client_node_id, cmd, self.client_process_tag, strace=self.strace, env=custom_env) |
| |
| |
| def __process_results(self, client_output, server_output): |
| parser_error = False |
| leak_detected = False |
| transfer_done = False |
| |
| parser_error, leak_detected = WeaveUtilities.scan_for_leaks_and_parser_errors(client_output) |
| |
| for line in client_output.split("\n"): |
| if "WEAVE:BDX: Transfer complete!" in line: |
| transfer_done = True |
| break |
| |
| if self.quiet == False: |
| if self.download: |
| print "weave-bdx from server v%s %s (%s) to client v%s %s (%s) : " % \ |
| (self.server_version, self.server_node_id, self.server_ip, |
| self.client_version, self.client_node_id, self.client_ip) |
| if transfer_done: |
| print hgreen("downloaded") |
| else: |
| print hred("not downloaded") |
| else: |
| print "weave-bdx from client %s (%s) to server %s (%s) : " % \ |
| (self.client_node_id, self.client_ip, |
| self.server_node_id, self.server_ip) |
| if transfer_done: |
| print hgreen("uploaded") |
| else: |
| print hred("not uploaded") |
| if leak_detected: |
| print hred("resource leak detected in the client's ouput") |
| if parser_error: |
| print hred("parser error in the client's output") |
| |
| |
| pass_test = transfer_done and not leak_detected and not parser_error |
| |
| if self.server is not "service": |
| # check the server for leaks and parser errors |
| parser_error, leak_detected = WeaveUtilities.scan_for_leaks_and_parser_errors(server_output) |
| if self.quiet == False: |
| if leak_detected: |
| print hred("resource leak detected in the server's ouput") |
| if parser_error: |
| print hred("parser error in the server's output") |
| |
| pass_test = pass_test and not parser_error and not leak_detected |
| |
| return (pass_test, client_output) |
| |
| |
| def __wait_for_client(self): |
| self.wait_for_test_to_end(self.client_node_id, self.client_process_tag) |
| |
| |
| def __stop_server_side(self): |
| self.stop_weave_process(self.server_node_id, self.server_process_tag) |
| |
| |
| def __stop_plaid_server(self): |
| self.plaid.stopPlaidServerProcess() |
| |
| |
| def run(self): |
| self.logger.debug("[localhost] WeaveBDX: Run.") |
| |
| self.__pre_check() |
| |
| if self.server is "service": |
| self.__start_client_side() |
| self.__wait_for_client() |
| |
| client_output_value, client_output_data = \ |
| self.get_test_output(self.client_node_id, self.client_process_tag, True) |
| if self.strace: |
| client_strace_value, client_strace_data = \ |
| self.get_test_strace(self.client_node_id, self.client_process_tag, True) |
| |
| status, results = self.__process_results(client_output_data, '') |
| # status = 0 |
| data = {} |
| data["client_output"] = client_output_data |
| else: |
| if self.use_plaid: |
| self.__start_plaid_server() |
| |
| self.__start_server_side() |
| |
| emsg = "WeaveBDX %s should be running." % (self.server_process_tag) |
| self.logger.debug("[%s] WeaveBDX: %s" % (self.server_node_id, emsg)) |
| |
| self.__start_client_side() |
| self.__wait_for_client() |
| |
| client_output_value, client_output_data = \ |
| self.get_test_output(self.client_node_id, self.client_process_tag, True) |
| if self.strace: |
| client_strace_value, client_strace_data = \ |
| self.get_test_strace(self.client_node_id, self.client_process_tag, True) |
| |
| 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) |
| |
| status, results = self.__process_results(client_output_data, server_output_data) |
| |
| data = {} |
| 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 |
| |
| self.logger.debug("[localhost] WeaveBDX: Done.") |
| return ReturnMsg(status, data) |
| |
