def run(self): self.__pre_check() self.__get_addresses() if self.addresses == {}: emsg = "No address to ping at " + str(self.destination) + "." self.logger.warning("[%s] Ping: %s" % (self.source, emsg)) print hyellow(emsg) return ReturnMsg(100, self.addresses) for addr in self.addresses.keys(): out, err = self.__ping_on_address(addr) self.__parse_output(addr, out, err) self.__post_check() for addr in self.addresses.keys(): if self.isIpAddress(self.destination): self.logger.info("ping from " + self.source + " to address " + addr + " -> " + str(self.addresses[addr]) + "% packet loss") else: self.logger.info("ping from " + self.source + " to " + self.destination + " on address " + addr + " -> " + str(self.addresses[addr]) + "% packet loss") return ReturnMsg(self.ret, self.addresses)
def run(self): self.__pre_check() if not self.delete and not self.key: self.__print_configuration(self.config_type) return ReturnMsg(0) if self.config_type == 'user': d = self.configuration elif self.config_type == 'main': d = self.main_conf elif self.config_type == 'log': d = self.log_conf if self.delete: if self.delete in list(d.keys()): del d[self.delete] if self.key is not None and self.value is not None: d[self.key] = self.value if self.key is not None and self.value is None: print("\t" + self.key + "\t", end=' ') if self.key in list(d.keys()): print(d[self.key]) else: print("not defined") self.writeConfiguration(d, self.config_type) return ReturnMsg(0)
def run(self): self.__pre_check() if self.node_id is None: self.__print_all_nodes() return 0 data_state = json.dumps(self.getNode(self.node_id), sort_keys=True, indent=4) emsg = "virtual node state: " + self.node_id print emsg self.logger.info("[%s] HappyNodeStatus: %s" % (self.node_id, emsg)) print data_state for line in data_state.split("\n"): if line is None or len(line) == 0: continue self.logger.info("[%s] HappyNodeStatus: %s" % (self.node_id, line)) self.__post_check() return ReturnMsg(0)
def run(self): self.logger.debug("[localhost] WeaveInetDNS: Run.") self.__pre_check() self.__start_node_dnscheck() emsg = "WeaveInet %s should be running." % (self.node_process_tag) self.logger.debug("[%s] WeaveInet: %s" % (self.node_id, emsg)) self.__stop_node() node_output_value, node_output_data = \ self.get_test_output(self.node_id, self.node_process_tag, True) node_strace_value, node_strace_data = \ self.get_test_strace(self.node_id, self.node_process_tag, True) results = self.__gather_results() result, output = self.__process_results(results) data = {} data["node_output"] = node_output_data data["node_strace"] = node_strace_data self.logger.debug("[localhost] WeaveInetDNSTest: Done.") return ReturnMsg(result, data)
def run(self): self.__pre_check() cmd = "" if self.run_as_user: try: user = os.environ['USER'] cmd = self.runAsUser(cmd, user) except Exception: pass env = os.environ env["PS1"] = r'\u@' + '\[\e[1;32m\]' + self.node_id + '\[\e[m\]' + ':\w\$ ' env["HAPPY_HOST"] = self.node_id if self.command: cmd += self.command else: cmd += 'bash --norc' self.result = self.CallAtNode(self.node_id, cmd, env, output='shell') self.__post_check() return ReturnMsg(0)
def run(self): if not self.add and not self.delete: data_state = json.dumps(self.getNodeInterfaceAddresses( self.interface, self.node_id), sort_keys=True, indent=4) emsg = "virtual node: " + self.node_id + " addresses list for interface id: " + self.interface print(emsg) print(data_state) else: with self.getStateLockManager(): self.__pre_check() if not self.done: if not self.IsTapDevice(self.node_id): if self.add: self.__add_address() else: self.__delete_address() self.__post_check() self.__update_state() self.writeState() return ReturnMsg(0)
def run(self): with self.getStateLockManager(): self.__pre_check() if not self.done: self.__stop_node_processes() self.__delete_node_interfaces() self.__delete_node_tmux_sessions() self.__delete_node() self.__post_check() self.__delete_node_state() self.__delete_node_dir() self.__delete_identifier_state() self.__delete_netns_state() self.writeState() return ReturnMsg(0)
def run(self): with self.getStateLockManager(): self.__pre_check() self.__create_link() self.__post_check_1() self.__get_node_interface_info() self.__connect_to_network() self.__connect_to_node() self.__nmconf() self.__check_node_hw_addr() self.__bring_up_interface() self.__post_check_2() self.__add_new_interface_state() self.writeState() self.__assign_network_addresses() self.__load_network_routes() return ReturnMsg(0)
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)
def run(self): results = {} self.logger.debug("[localhost] WeaveInet: Run.") self.__pre_check() self.__start_receiver() self.logger.debug("[%s] WeaveInet: receiver should be running." % ("localhost")) emsg = "receiver %s should be running." % (self.receiver['tag']) self.logger.debug("[%s] WeaveInet: %s" % (self.receiver['node'], emsg)) self.__start_sender() self.__wait_for_sender() self.__stop_receiver() # Gather results from the sender and receivers results = self.__gather_results() # Process the results from the sender and receivers into a # singular status value and a results dictionary containing # process output. status, results = self.__process_results(results) self.logger.debug("[localhost] WeaveInet: Done.") return ReturnMsg(status, results)
def run(self): # query node's route ip in v4 or v6 format. if not self.add and not self.delete: route_ip = self.getNodeRoute(self.node_id, self.route_type) emsg = "virtual node: {}, route_type: {}, route ip: {}".format( self.node_id, self.route_type, route_ip) print emsg else: self.__pre_check() # only configure route for nonTAP device # for TAP device, route will be configured in lwip stack in weave. if not self.IsTapDevice(self.node_id): if self.route_table is not None: with self.getStateLockManager(lock_id="rt"): if self.add: self.__add_route() else: self.__delete_route() else: if self.add: self.__add_route() else: self.__delete_route() self.__post_check() with self.getStateLockManager(): self.__update_state() self.writeState() return ReturnMsg(0)
def run(self): self.logger.debug("[localhost] WeaveDeviceDescription: Run.") self.__pre_check() self.__start_server_side() time.sleep(0.1) emsg = "WeaveDeviceDescription %s should be running." % (self.server_process_tag) self.logger.debug("[%s] WeaveDeviceDescription: %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) client_strace_value, client_strace_data = \ self.get_test_strace(self.client_node_id, self.client_process_tag, True) 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) status, results = self.__process_results(client_output_data) data = {} data["client_output"] = client_output_data data["client_strace"] = client_strace_data data["server_output"] = server_output_data data["server_strace"] = server_strace_data self.logger.debug("[localhost] WeaveDeviceDescription: Done.") return ReturnMsg(status, data)
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): self.__pre_check() self.__leave() self.__post_check() return ReturnMsg(0)
def run(self): self.__pre_check() self.__list_networks() self.__post_check() return ReturnMsg(0)
def run(self): self.__pre_check() self.__show_links() self.__post_check() return ReturnMsg(0)
def run(self): self.__pre_check() self.__list_nodes() self.__post_check() return ReturnMsg(0, self.nodes)
def run(self): all_data = [] result_list = [] self.logger.debug("[localhost] WeaveBle: Run.") self.__pre_check() self.initializeBluez() delayExecution(5) self.__start_server_side() emsg = "WeaveBle Peripheral %s should be running." % ( self.server_process_tag) self.logger.debug("[%s] WeaveBle: %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) data = {} data.update(client_info) data["client_output"] = client_output_data data["server_output"] = server_output_data if "WoBLE central is good to go" in client_output_data: result_list.append(True) else: result_list.append(False) if self.strace: data["client_strace"] = client_strace_data data["server_strace"] = server_strace_data all_data.append(data) self.resetBluez() self.logger.debug("[localhost] WeaveBle: Done.") return ReturnMsg(result_list, all_data)
def run(self): with self.getStateLockManager(): self.__pre_check() self.global_prefix = self.getWeaveGlobalPrefix(self.fabric_id) self.__add_fabric_state() self.writeState() self.__post_check() return ReturnMsg(0)
def run(self): self.__pre_check() if self.process_exists: self.__stop_process() self.__post_check() return ReturnMsg(0)
def run(self): with self.getStateLockManager(): self.__pre_check() if self.done: return ReturnMsg(0) self.global_prefix = self.getWeaveGlobalPrefix(self.fabric_id) self.__delete_nodes_addresses() with self.getStateLockManager(): self.readState() self.__delete_nodes_state() self.__delete_fabric_state() self.writeState() return ReturnMsg(0)
def run(self): self.logger.debug("[localhost] WeaveSWU: Run.") self.__pre_check() if self.announceable: self.__start_client_side() delayExecution(0.5) emsg = "WeaveSWU %s should be running." % (self.client_process_tag) self.logger.debug("[%s] WeaveSWU: %s" % (self.client_node_id, emsg)) self.__start_server_side() self.__wait_for_client() client_output_value, client_output_data = \ self.get_test_output(self.client_node_id, self.client_process_tag, True) client_strace_value, client_strace_data = \ self.get_test_strace(self.client_node_id, self.client_process_tag, True) 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) else: self.__start_server_side() emsg = "WeaveSWU %s should be running." % (self.server_process_tag) self.logger.debug("[%s] WeaveSWU: %s" % (self.server_node_id, emsg)) delayExecution(0.5) 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) client_strace_value, client_strace_data = \ self.get_test_strace(self.client_node_id, self.client_process_tag, True) 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) status, results = self.__process_results(client_output_data) data = {} data["client_output"] = client_output_data data["client_strace"] = client_strace_data data["server_output"] = server_output_data data["server_strace"] = server_strace_data self.logger.debug("[localhost] WeaveSWU: Done.") return ReturnMsg(status, data)
def run(self): self.logger.debug("[localhost] WeaveSecurityPing: Run.") self.__pre_check() if self.use_plaid: self.__start_plaid_server() self.__start_server_side() emsg = "WeaveSecurityPing %s should be running." % ( self.server_process_tag) self.logger.debug("[%s] WeaveSecurityPing: %s" % (self.server_node_id, emsg)) self.__start_client_side(False) 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) 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) avg, results = self.__process_results(client_output_data) client_parser_error, client_leak_detected = WeaveUtilities.scan_for_leaks_and_parser_errors( client_output_data) server_parser_error, server_leak_detected = WeaveUtilities.scan_for_leaks_and_parser_errors( 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 data[ "other_failure"] = client_parser_error or client_leak_detected or server_parser_error or server_leak_detected self.logger.debug("[localhost] WeaveSecurityPing: Done.") return ReturnMsg(avg, data)
def run(self): with self.getStateLockManager(): self.__pre_check() self.__load_JSON() self.__post_check() self.__unload_network_topology() return ReturnMsg(0)
def run(self): with self.getStateLockManager(): self.__pre_check() self.__update_nodes_dns() self.__dns_state() self.writeState() return ReturnMsg(0)
def run(self): self.__pre_check() self.__get_internet_interface_info() if self.add: with self.getStateLockManager(lock_id="isp"): self.readIspState() # print self.getStateId() self.isp_pool = self.getIsp() if not bool(self.isp_pool): self.__initialize_isp_pool() self.__create_isp_internet_link() self.__create_isp() self.__connect_internet_to_isp() self.__ctrl_isp_internet_interface() self.__nmconf() self.__assign_isp_internet_address() self.__nat_host() self.__get_isp_from_pool() self.writeIspState() self.__create_isp_link() self.__connect_node_to_isp() self.__assign_isp_address() self.__ctrl_isp_node_interface() with self.getStateLockManager(lock_id="rt"): self.__route() self.__nat_isp_node() with self.getStateLockManager(): self.__internet_state() self.writeState() if self.delete: with self.getStateLockManager(): self.__route() self.__internet_state() self.writeState() self.__ctrl_isp_node_interface() with self.getStateLockManager(lock_id="isp"): self.readIspState() self.__release_isp_to_pool() if len(self.getIspAvailable()) == 254: self.__ctrl_isp_internet_interface() self.__delete_isp_internet_link() self.__delete_isp() self.removeGlobalIsp() self.writeIspState() return ReturnMsg(0)
def run(self): self.__pre_check() self.__delete_state() self.__delete_state_file() if self.all: self.__cleanup_host() self.__post_check() return ReturnMsg(0)
def run(self): self.__pre_check() if not self.done: emsg = "Waiting for process %s to complete." % (self.tag) self.logger.debug("[%s] HappyProcessWait: %s" % (self.node_id, emsg)) self.BlockOnProcess(self.tag, self.node_id, self.timeout) else: emsg = "Process %s already completed." % (self.tag) self.logger.debug("[%s] HappyProcessWait: %s" % (self.node_id, emsg)) return ReturnMsg(0)
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)
def run(self): with self.getStateLockManager(): self.__pre_check() self.__configure_network_route() self.__post_check() self.__update_state() self.writeState() return ReturnMsg(0)