def _run_linux(self, cmd, expect_fail, detach=False): ret_value = None _cmd = cmd if detach: _cmd = "nohup {} &> /dev/null &".format(cmd) logger.info("[LDROPLET {}]: running: {}".format(self.id, _cmd)) out = self.conn.run(_cmd, warn=True) if not detach: ret_value = (out.exited, out.stdout.strip()) if (not detach and ret_value[0] != 0): if not expect_fail: logger.error("[LDROPLET {}]: {}".format(self.id, ret_value[1])) else: logger.info("[LDROPLET {}]: {}".format(self.id, ret_value[1])) if not detach: logger.debug( "[LDROPLET {}]: running\n command:\n {}, \n exit_code: {},\n output:\n {}" .format(self.id, _cmd, ret_value[0], ret_value[1])) return ret_value
def do_run_get_rpc_test(test, droplet, call): """ Helper function for verifying delete RPC was successful """ if call[0] == "ep " + droplet.phy_itf or call[ 0] == "ep_substrate " + droplet.phy_itf: log_string = "[DROPLET {}]: Expecting failure for RPC call.".format( droplet.id) cmd = f'''{droplet.trn_cli_get_ep} \'{call[1]}\'''' return droplet.exec_cli_rpc(log_string, cmd, True)[0] elif call[0] == "net " + droplet.phy_itf: log_string = "[DROPLET {}]: Expecting failure for RPC call.".format( droplet.id) cmd = f'''{droplet.trn_cli_get_net} \'{call[1]}\'''' return droplet.exec_cli_rpc(log_string, cmd, True)[0] elif call[0] == "vpc " + droplet.phy_itf: log_string = "[DROPLET {}]: Expecting failure for RPC call.".format( droplet.id) cmd = f'''{droplet.trn_cli_get_vpc} \'{call[1]}\'''' return droplet.exec_cli_rpc(log_string, cmd, True)[0] elif call[ 0] == "load": # We assume agent was loaded and unloaded correctly return 1 else: logger.error("[{}]: Unidentified rpc call: {}@{}".format( droplet.id, call[0], call[1])) return 0
def _get_linux_file(self, path): logger.error("[LDROPLET {}]: Fetching file {}".format(self.id, path)) fd = BytesIO() self.conn.get(path, '/tmp/resultdata') with open('/tmp/resultdata', 'r') as datfile: data = datfile.read() return data
def bootstrap(self): if self.droplet_type == 'docker': self._create_docker_container() self.load_transit_xdp() self.start_pcap() return logger.error("Unsupported droplet type!")
def get_file(self, path): if self.droplet_type == 'docker': return self._get_docker_file(path) if self.droplet_type == 'linux': return self._get_linux_file(path) logger.error("Unsupported droplet type!")
def bootstrap(self): if self.droplet_type == 'docker': self._create_docker_container() return if self.droplet_type == 'linux': self.prepare_remote_host() return logger.error("Unsupported droplet type!")
def run(self, cmd, detach=False, expect_fail=False): """ Runs a command directly on the droplet """ if self.droplet_type == 'docker': return self._run_docker(cmd, expect_fail, detach) if self.droplet_type == 'linux': return self._run_linux(cmd, expect_fail, detach) logger.error("Unsupported droplet type!")
def do_check_failed_rpcs(test, droplets): exit_code = 0 logger.info("{} Checking for unexpected failed RPC calls {}".format( '=' * 20, '=' * 20)) for d in droplets: if len(d.rpc_failures.keys()) > 0: exit_code = 1 for cmd in d.rpc_failures.keys(): logger.error( "[DROPLET {}]: Unexpected failed command ran: {} at {}". format(d.id, d.rpc_failures[cmd], cmd)) print() test.assertEqual(exit_code, 0)
def local(self, cmd): ret_value = None logger.info("[LOCAL {}]: running: {}".format(self.id, cmd)) try: out = run_cmd(cmd) ret_value = (out[0], out[1]) if (ret_value[0] != 0): logger.error("[LOCAL {}]: {}".format(self.id, ret_value[1])) logger.debug( "[LOCAL {}]: running\n command:\n {}, \n exit_code: {},\n output:\n {}" .format(self.id, cmd, ret_value[0], ret_value[1])) return ret_value except Exception as e: logger.error("[LOCAL {}]: {}".format(self.id, str(e))) return None
def run(self, cmd, detach=False): """ Runs a command directly on the droplet """ ret_value = None if (self.droplet_type == 'docker'): out = self.container.exec_run(cmd, detach=detach) if not detach: ret_value = (out.exit_code, out.output.decode("utf-8")) logger.info("[DROPLET {}]: running: {}".format(self.id, cmd)) if (not detach and ret_value[0] == 1): logger.error("[DROPLET {}]: {}".format(self.id, ret_value[1])) if not detach: logger.debug( "[DROPLET {}]: running\n command:\n {}, \n exit_code: {},\n output:\n {}".format(self.id, cmd, ret_value[0], ret_value[1])) return ret_value
def _run_docker(self, cmd, expect_fail, detach=False): ret_value = None out = self.container.exec_run(cmd, detach=detach) if not detach: ret_value = (out.exit_code, out.output.decode("utf-8")) logger.info("[DROPLET {}]: running: {}".format(self.id, cmd)) if (not detach and ret_value[0] != 0): if not expect_fail: logger.error("[LDROPLET {}]: {}".format(self.id, ret_value[1])) else: logger.info("[LDROPLET {}]: {}".format(self.id, ret_value[1])) if not detach: logger.debug( "[DROPLET {}]: running\n command:\n {}, \n exit_code: {},\n output:\n {}" .format(self.id, cmd, ret_value[0], ret_value[1])) return ret_value
def do_validate_delete_test(test, droplets): """ Validates deletes RPC calls are correctly made after an update. * Condition #1: All update calls have a corresponding delete. # 2: All delete calls happen AFTER their corresponding update call is made. * Condition * Condition #3: All corresponding get RPC calls return an error after delete """ exit_code = 0 for d in droplets: for update in d.rpc_updates: if update not in d.rpc_deletes.keys(): exit_code = 1 logger.error( "[{}]: No corresponding delete call was made for the update. {}" .format(d.id, update)) test.assertEqual(exit_code, 0) if d.rpc_updates[update] > d.rpc_deletes[update]: exit_code = 1 logger.error( "[{}]: The following update was made after delete was called. {}" .format(d.id, update)) test.assertEqual(exit_code, 0) if do_run_get_rpc_test(test, d, update) == 0: exit_code = 1 logger.error( "[{}]: Get RPC returned a valid object after delete. {}". format(d.id, update)) test.assertEqual(exit_code, 0) test.assertEqual(exit_code, 0)
def do_check_failed_rpcs(test, droplets): """ Checks to see if any RPCs ran on the given list of droplets returned an error. """ exit_code = 0 logger.info("{} Checking for unexpected failed RPC calls {}".format( '=' * 20, '=' * 20)) for d in droplets: if len(d.rpc_failures.keys()) > 0: exit_code = 1 for cmd in d.rpc_failures.keys(): logger.error( "[DROPLET {}]: Unexpected failed command ran: {} at {}". format(d.id, d.rpc_failures[cmd], cmd)) print() if exit_code == 0: logger.info("{} No failed RPC calls found! {}".format( '=' * 20, '=' * 20)) else: logger.error("{} Found failed RPC calls! {}".format( '=' * 20, '=' * 20)) test.assertEqual(exit_code, 0)
def update_agent_ep(self, itf): logger.error( "[DROPLET {}]: not implemented, no use case for now!".format( self.id))