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)
