def SetupDNSServer(server): node = server.node_name workload = server.workload_name dir_path = os.path.dirname(os.path.realpath(__file__)) zonefile = dir_path + '/' + "example.com.zone" api.Logger.info("fullpath %s" % (zonefile)) resp = api.CopyToWorkload(node, workload, [zonefile], 'dnsdir') if resp is None: return None named_conf = dir_path + '/' + "named.conf" resp = api.CopyToWorkload(node, workload, [named_conf], 'dnsdir') if resp is None: return None req = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddCommand(req, node, workload, "yes | cp dnsdir/named.conf /etc/") api.Trigger_AddCommand( req, node, workload, "ex -s -c \'%s/192.168.100.102/%s/g|x\' /etc/named.conf" % ("%s", server.ip_address)) api.Trigger_AddCommand(req, node, workload, "yes | cp dnsdir/example.com.zone /var/named/") api.Trigger_AddCommand(req, node, workload, "systemctl start named") api.Trigger_AddCommand(req, node, workload, "systemctl enable named") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) for cmd in trig_resp.commands: api.PrintCommandResults(cmd) return api.types.status.SUCCESS
def Setup(tc): api.Logger.info("Setup.") tc.pcap_file_name = None tc.dir_path = os.path.dirname(os.path.realpath(__file__)) tc.test_mss = 900 if tc.iterators.kind == "remote": pairs = api.GetRemoteWorkloadPairs() if not pairs: api.Logger.info("no remtote eps") return api.types.status.SUCCESS else: pairs = api.GetLocalWorkloadPairs() tc.resp_flow = getattr(tc.args, "resp_flow", 0) tc.cmd_cookies = {} req = api.Trigger_CreateExecuteCommandsRequest(serial=True) if pairs[0][0].IsNaples(): tc.client, tc.server = pairs[0] else: tc.server, tc.client = pairs[0] fullpath = tc.dir_path + '/' + "scapy_3way.py" resp = api.CopyToWorkload(tc.server.node_name, tc.server.workload_name, [fullpath]) resp = api.CopyToWorkload(tc.client.node_name, tc.client.workload_name, [fullpath]) cmd_cookie = start_nc_server(tc.server, "1237") add_command(req, tc, 'server', tc.server, cmd_cookie, True) ret = __add_remove_tcp_drop_rule(tc.client) if ret != api.types.status.SUCCESS: api.Logger.error( f"Failed to drop the drop rule on {tc.client.workload_name}") return ret #start session cmd_cookie = "sudo -E python3 ./scapy_3way.py {} {}".format( tc.client.ip_address, tc.server.ip_address) api.Trigger_AddCommand(req, tc.client.node_name, tc.client.workload_name, cmd_cookie, False) cmd_cookie = "/nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format( tc.server.ip_address) add_command(req, tc, 'show before', tc.client, cmd_cookie, naples=True) tc.first_resp = api.Trigger(req) cmd = tc.first_resp.commands[-1] api.PrintCommandResults(cmd) tc.pre_ctrckinf = get_conntrackinfo(cmd) if getattr(tc.args, 'vmotion_enable', False): vmotion_utils.PrepareWorkloadVMotion(tc, [tc.client]) return api.types.status.SUCCESS
def Setup(tc): tc.skip = False tc.workload_pairs = tc.selected if len(tc.workload_pairs) == 0: api.Logger.info("Skipping Testcase due to no workload pairs.") tc.skip = True wloads = set() for w1, w2, port in tc.workload_pairs: wloads.add(w1) wloads.add(w2) fullpath = api.GetTopDir() + '/iota/bin/fuz' for w in wloads: resp = api.CopyToWorkload(w.node_name, w.workload_name, [fullpath], '') #Create a symlink at top level realPath = "realpath fuz" req = api.Trigger_CreateExecuteCommandsRequest() api.Trigger_AddCommand(req, w.node_name, w.workload_name, realPath, background=False) resp = api.Trigger(req) for cmd in resp.commands: api.PrintCommandResults(cmd) if cmd.exit_code != 0: return api.types.status.FAILURE FUZ_EXEC[cmd.entity_name] = cmd.stdout.split("\n")[0] return api.types.status.SUCCESS
def copyTestCommand(tc): test_reject_file = os.path.join(os.path.dirname(__file__), "test_reject.py") req = api.Trigger_CreateExecuteCommandsRequest(serial = True) path_to_copy = "test_reject_script" for w in tc.workload_dict.keys(): api.Logger.info("Copying file %s to %s:%s"% (test_reject_file, w.workload_name, path_to_copy)) resp = api.CopyToWorkload(w.node_name, w.workload_name, [test_reject_file], path_to_copy) if resp is None: api.Logger.error("Failed to copy test reject command to %s"%w.workload_name) return False api.Trigger_AddCommand(req, w.node_name, w.workload_name, "yes | mv %s/test_reject.py /usr/local/bin"%(path_to_copy)) api.Trigger_AddCommand(req, w.node_name, w.workload_name, "yes | chmod 755 /usr/local/bin/test_reject.py") trig_resp = api.Trigger(req) for cmd in trig_resp.commands: api.PrintCommandResults(cmd) return True
def SetupNFSServer(server, client, nfs=True): req = api.Trigger_CreateExecuteCommandsRequest(serial=True) node = server.node_name workload = server.workload_name api.Trigger_AddCommand(req, node, workload, "sudo chkconfig nfs on") api.Trigger_AddCommand(req, node, workload, "sudo service rpcbind start") api.Trigger_AddCommand(req, node, workload, "sudo service nfs start") if (nfs == True): api.Trigger_AddCommand(req, client.node_name, client.workload_name, "rpcinfo -s %s" % (server.ip_address)) api.Trigger_AddCommand(req, node, workload, "mkdir /home/sunrpcmntdir") api.Trigger_AddCommand(req, node, workload, "sudo chmod 777 /home/sunrpcmntdir") api.Trigger_AddCommand( req, node, workload, "sudo echo \'/home/sunrpcmntdir %s(rw,sync,no_subtree_check,no_root_squash)\' | sudo tee -a /etc/exports" % (client.ip_address)) api.Trigger_AddCommand(req, node, workload, "sudo exportfs -ra") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) for cmd in trig_resp.commands: api.PrintCommandResults(cmd) rpcfile = dir_path + '/' + "sunrpc_file.txt" f = open(rpcfile, "w") f.write("Hello World!!!\n") f.close() resp = api.CopyToWorkload(client.node_name, client.workload_name, [rpcfile], 'sunrpcdir') os.remove(rpcfile) return api.types.status.SUCCESS
def SetupPacketScapy(tc): pktscapyscript = api.GetTopDir() + '/' + dir_path + "packet_scapy.py" for wl in tc.workloads: resp = api.CopyToWorkload(wl.node_name, wl.workload_name, [pktscapyscript], "") if resp is None: api.Logger.info("Failed to copy packet scapy script to WL:%s"%wl.workload_name) return api.types.status.FAILURE return api.types.status.SUCCESS
def SetupTFTPClient(client): node = client.node_name workload = client.workload_name fullpath = dir_path + '/' + "tftp_client.txt" api.Logger.info("fullpath %s" % (fullpath)) resp = api.CopyToWorkload(node, workload, [fullpath], 'tftpdir') if resp is None: return None return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() server = pairs[0][0] client = pairs[0][1] tc.cmd_cookies = [] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS req = api.Trigger_CreateExecuteCommandsRequest(serial = True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr)) dir_path = os.path.dirname(os.path.realpath(__file__)) fullpath = dir_path + '/' + "small.vob" api.Logger.info("fullpath %s" % (fullpath)) resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir') if resp is None: return api.types.status.FAILURE api.Trigger_AddCommand(req, client.node_name, client.workload_name, "ls -al | grep video") tc.cmd_cookies.append("Before RTSP") server_cmd = "cd rtspdir && live555MediaServer" api.Trigger_AddCommand(req, server.node_name, server.workload_name, server_cmd, background = True) tc.cmd_cookies.append("Run RTSP server") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "openRTSP rtsp://%s/small.vob" % server.ip_address) tc.cmd_cookies.append("Run RTSP client") ## Add Naples command validation api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg rtsp --yaml") tc.cmd_cookies.append("show session RTSP established") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate | grep RTSP") tc.cmd_cookies.append("show flow-gate") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "ls -al | grep video") tc.cmd_cookies.append("After RTSP") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def copy_to_entity(entity): fullpath = api.GetTopDir() + '/iota/bin/fuz' resp = api.CopyToWorkload(entity.node_name, entity.workload_name, [fullpath], '') #Create a symlink at top level realPath = "realpath fuz" req = api.Trigger_CreateExecuteCommandsRequest() api.Trigger_AddCommand(req, entity.node_name, entity.workload_name, realPath, background = False) resp = api.Trigger(req) for cmd in resp.commands: api.PrintCommandResults(cmd) if cmd.exit_code != 0: return api.types.status.FAILURE tc.fuz_exec[cmd.entity_name] = cmd.stdout.split("\n")[0] return api.types.status.SUCCESS
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS store = tc.GetBundleStore() cps = int(getattr(tc.args, "cps", 500)) attempts = int(getattr(tc.args, "attempts", 3)) sessions = int(getattr(tc.args, "num_sessions", 1)) session_time = str(getattr(tc.args, "session_time", "10")) + "s" static_arp = int(getattr(tc.args, "static_arp", False)) if static_arp: #install arp entries before running arpReqs = store["arp_ctx"] api.Trigger(arpReqs) #Spread CPS evenly clientReq = api.Trigger_CreateAllParallelCommandsRequest() cps_per_node = int(cps / len(store["client_ctxts"])) for index, (_, client) in enumerate(store["client_ctxts"].items()): jsonInput = {"connections": []} for serverIPPort in client.GetServers(): jsonInput["connections"].append({ "ServerIPPort": serverIPPort, "proto": "tcp" }) outfile = api.GetTestDataDirectory( ) + "/" + client.workload_name + "_fuz.json" with open(outfile, 'w') as fp: json.dump(jsonInput, fp) api.CopyToWorkload(client.node_name, client.workload_name, [outfile], "") clientCmd = fuz_init.FUZ_EXEC[ client.workload_name] + " -attempts " + str( attempts) + " -duration " + session_time + " -conns " + str( sessions) + " -cps " + str( cps_per_node ) + " -talk --jsonOut --jsonInput " + os.path.basename( outfile) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, background=True) #Initiate connections store["client_req"] = api.Trigger(clientReq) return api.types.status.SUCCESS
def SetupFTPClient(node, workload): ftpdata = dir_path + '/' + "ftp_client.txt" api.Logger.info("fullpath %s" % (ftpdata)) resp = api.CopyToWorkload(node, workload, [ftpdata], 'ftpdir') if resp is None: return None req = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddCommand(req, node, workload, "mkdir /home/admin/ftp") api.Trigger_AddCommand(req, node, workload, "cp ftpdir/ftp_client.txt /home/admin/ftp/") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) for cmd in trig_resp.commands: api.PrintCommandResults(cmd) return api.types.status.SUCCESS
def SetupFTPMediator(node, workload): ftpcommand = dir_path + '/' + ".lftprc" f = open(ftpcommand, "w") f.write("set ftp:use-fxp true\n") f.close() resp = api.CopyToWorkload(node, workload, [ftpcommand], 'ftpdir') if resp is None: return None req = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddCommand(req, node, workload, "cp ftpdir/.lftprc ~/") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) for cmd in trig_resp.commands: api.PrintCommandResults(cmd) return api.types.status.SUCCESS
def _createTrexCfg(self): cfgFile = None try: req = api.Trigger_CreateExecuteCommandsRequest() self._removeTrexCfg() if self.role == 'client': cfgFile = self._getTrexCfg(self.workload.interface, "dummy", \ self.workload.ip_address, "0.0.0.0", \ self.gw, "0.0.0.0") else: cfgFile = self._getTrexCfg("dummy", self.workload.interface, \ "0.0.0.0", self.workload.ip_address, \ "0.0.0.0", self.gw) api.Logger.info("Configuration for TRex server file:%s, workload: %s"% (cfgFile.name, self.workload.workload_name)) cfgFileName = cfgFile.name.split("/")[-1] resp = api.CopyToWorkload(self.workload.node_name, self.workload.workload_name, [cfgFile.name]) if not resp: raise Exception("Failed to copy TRex configuration to %s "%()) api.Trigger_AddCommand(req, self.workload.node_name, self.workload.workload_name, "yes | mv %s %s"%(cfgFileName, DEFAULT_TREX_CFG_PATH)) resp = api.Trigger(req) for cmd in resp.commands: api.PrintCommandResults(cmd) if cmd.exit_code: raise Exception("Failed to create TRex configuration on %s"% self.workload.workload_name) self._verifyTrexCfg() api.Logger.info("Created TRex configuration on %s"% self.workload.workload_name) finally: if cfgFile: cfgFile.close()
def ICMPv6Test(tc, packet_type): req = api.Trigger_CreateExecuteCommandsRequest(serial = True) tc.cmd_cookies = [] for wl in tc.workloads: # Use only untagged WL for now if wl.uplink_vlan != 0: continue # Pick Naples workload as the source for packet tx if not wl.IsNaples(): continue # Form ICMPv6 NS Packet PCAP file and copy to WL pcap_file_full_path, pcap_file = GetICMPv6PacketPcap(wl, packet_type) if pcap_file is None: api.Logger.error("Failed to get PCAP file for packet: %s, for WL:%s"%(packet_type,wl.workload_name)) continue resp = api.CopyToWorkload(wl.node_name, wl.workload_name, [pcap_file_full_path], "") if resp is None: api.Logger.error("Failed to copy PCAP file %s to WL:%s"%(pcap_file,wl.workload_name)) continue # get drop stats before test naples_cmd = r"/nic/bin/pdsctl show system statistics drop | grep nacl" api.Trigger_AddNaplesCommand(req, wl.node_name, naples_cmd) tc.cmd_cookies.append("NACL Drops at start of test") # Send ICMPv6 NS cmd_cookie = "Send %s packets from %s(%s, %s)" % \ (packet_type, wl.workload_name, "2001:bade:cd8::1", wl.interface) tc.cmd_cookies.append(cmd_cookie) cmd = "sh -c 'chmod +x packet_scapy.py && ./packet_scapy.py --pcap-file %s --iface %s --count %s'"%(pcap_file,wl.interface,icmpv6_pkt_count) api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, cmd) # get drop stats before test naples_cmd = r"/nic/bin/pdsctl show system statistics drop | grep nacl" api.Trigger_AddNaplesCommand(req, wl.node_name, naples_cmd) tc.cmd_cookies.append("NACL Drops at end of test") tc.resp = api.Trigger(req) if tc.resp is None: return api.types.status.FAILURE return api.types.status.SUCCESS
def SetupDNSClient(client, server, qtype="NONE"): node = client.node_name workload = client.workload_name dnsscapy = dir_path + '/' + "dnsscapy.py" f = open(dnsscapy, "w") f.write("#! /usr/bin/python3\n") f.write("from scapy.all import *\n") f.write("import codecs\n") f.write("ip=IP(src=\"%s\", dst=\"%s\")\n" % (client.ip_address, server.ip_address)) if qtype == "LARGE_DOMAIN_NAME": f.write( "dnspkt=UDP(sport=53333,dport=53)/DNS(rd=1, qd=DNSQR(qname=\'%s\'))\n" % (LARGE_DOMAIN_NAME)) elif qtype == "LONG_LABEL": f.write( "data=\'0000010000010000000000003b49737468697361626967656e6f756768646f6d61696e6e616d65666f72617265616c6c6c6c6c6c7979797979626967646f6d61696e736572766572446f77746f636f6e73747275637461646f6d61696e6e616d65197468617469736c61726765727468616e7468656d6178696d756d646f6d61696e6e616d6573697a6518646f0e736e74736503636f6d0000010001\'\n" ) f.write( "dnspkt=UDP(sport=53333,dport=53)/codecs.decode(data, 'hex')\n") elif qtype == "MULTI_QUESTION": f.write( "dnspkt=UDP(sport=53333,dport=53)/DNS(rd=2,qd=DNSQR(qname='www.thepacketgeek.com')/DNSQR(qname='test3.example.com'))\n" ) elif qtype == "LABEL_PARSING_ERROR": f.write( "data=\'0000010000010000000000003b49737468697361626967656e6f756768646f6d61696e6e616d65666f72617265616c6c6c6c6c6c7979797979626967646f6d61696e736572766572686f77746f636f6e73747275637461646f6d61696e6e616d65197468617469736c61726765727468616e7468656d6178696d756d646f6d61696e6e616d6573697a6518646f0e736e74736503636f6d0000010001\'\n" ) f.write("sendp(Ether(src=\"%s\", dst=\"%s\")/ip/dnspkt, iface=\"%s\")\n" % (client.mac_address, server.mac_address, client.interface)) f.close() resp = api.CopyToWorkload(node, workload, [dnsscapy], 'dnsdir') if resp is None: return None os.remove(dnsscapy)
def SetupFTPClient(node, workload, server, mode): dir_path = os.path.dirname(os.path.realpath(__file__)) ftpcommand = dir_path + '/' + "ftp.sh" f = open(ftpcommand, "w") f.write("#!/bin/bash\n") f.write("ftp -inv %s <<EOF\n" % (server.ip_address)) f.write("user admin linuxpassword\n") f.write("cd /home/admin/ftp\n") f.write("pwd\n") f.write("dir\n") if (mode == 'active'): f.write("pass\n") f.write("ls\n") f.write("sleep 60\n") f.write("ls\n") f.write("sleep 120\n") f.write("mget ftp_server.txt\n") f.close() resp = api.CopyToWorkload(node, workload, [ftpcommand], 'ftpdir') if resp is None: return None return api.types.status.SUCCESS
def SetupTFTPServer(server, non_standard_port=False): node = server.node_name workload = server.workload_name fullpath = dir_path + '/' + "tftp_server.txt" api.Logger.info("fullpath %s" % (fullpath)) resp = api.CopyToWorkload(node, workload, [fullpath], 'tftpdir') if resp is None: return None req = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddCommand(req, node, workload, "cp tftpdir/tftp_server.txt /var/lib/tftpboot") api.Trigger_AddCommand(req, node, workload, "touch /var/lib/tftpboot/tftp_client.txt") api.Trigger_AddCommand(req, node, workload, "chmod 666 /var/lib/tftpboot/tftp_client.txt") if non_standard_port == True: api.Trigger_AddCommand(req, node, workload, "systemctl disable tftp") api.Trigger_AddCommand(req, node, workload, "systemctl stop tftp") api.Trigger_AddCommand( req, node, workload, "/usr/sbin/in.tftpd -s /var/lib/tftpboot -l --address %s:%s" % (server.ip_address, TFTP_NONSTD_PORT)) api.Trigger_AddCommand(req, node, workload, "touch /var/lib/tftpboot/tftp_client.txt") api.Trigger_AddCommand(req, node, workload, "chmod 666 /var/lib/tftpboot/tftp_client.txt") else: api.Trigger_AddCommand(req, node, workload, "systemctl start tftp") api.Trigger_AddCommand(req, node, workload, "systemctl enable tftp") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) for cmd in trig_resp.commands: api.PrintCommandResults(cmd) return api.types.status.SUCCESS
def Trigger(tc): api.Logger.info("Trigger.") if tc.iterators.kind == "remote": pairs = api.GetRemoteWorkloadPairs() if not pairs: api.Logger.info("no remtote eps") return api.types.status.SUCCESS else: pairs = api.GetLocalWorkloadPairs() resp_flow = getattr(tc.args, "resp_flow", 0) tc.cmd_cookies = {} req = api.Trigger_CreateExecuteCommandsRequest(serial = True) if pairs[0][0].IsNaples(): client,server = pairs[0] else: server,client = pairs[0] dir_path = os.path.dirname(os.path.realpath(__file__)) fullpath = dir_path + '/' + "scapy_3way.py" resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath]) resp = api.CopyToWorkload(client.node_name, client.workload_name, [fullpath]) cmd_cookie = start_nc_server(server, "1237") add_command(req, tc, 'server', server, cmd_cookie, True) #start session cmd_cookie = "sudo -E python3 ./scapy_3way.py {} {}".format(client.ip_address, server.ip_address) api.Trigger_AddCommand(req, client.node_name, client.workload_name, cmd_cookie,False) cmd_cookie = "/nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format(server.ip_address) add_command(req, tc, 'show before', client, cmd_cookie, naples=True) ''' iseq_num, iack_num, iwindo_sz, iwinscale, rseq_num, rack_num, rwindo_sz, rwinscale = get_conntrackinfo(cmd) req = api.Trigger_CreateExecuteCommandsRequest(serial = True) if resp_flow: new_seq_num = rseq_num + iwindo_sz * (2 ** iwinscale) req = api.Trigger_CreateExecuteCommandsRequest(serial = True) #left out of window - retransmit cmd_cookie = "hping3 -c 1 -s 1237 -p 52255 -M {} -L {} --ack --tcp-timestamp {} -d 10".format(wrap_around(rseq_num, 0), rack_num, client.ip_address) add_command(req, tc, 'fail ping', server, cmd_cookie) else: new_seq_num = iseq_num + rwindo_sz * (2 ** rwinscale) #left out of window - retransmit cmd_cookie = "hping3 -c 1 -s 52255 -p 1237 -M {} -L {} --ack --tcp-timestamp {} -d 10".format(wrap_around(iseq_num, 0), iack_num, server.ip_address) add_command(req, tc,"fail ping", client, cmd_cookie) cmd_cookie = "sleep 3 && /nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format(server.ip_address) add_command(req, tc, 'show after', client, cmd_cookie, naples=True) ''' cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', client, cmd_cookie, naples=True) if server.IsNaples(): cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', server, cmd_cookie, naples=True) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): if tc.skip: return api.types.status.SUCCESS store = tc.GetBundleStore() cps = int(getattr(tc.args, "cps", 500)) pcap_capture = int(getattr(tc.args, "pcap", False)) sessions = int(getattr(tc.args, "num_sessions", 1)) session_time = str(getattr(tc.args, "session_time", "10")) + "s" static_arp = int(getattr(tc.args, "static_arp", False)) if static_arp: #install arp entries before running arpReqs = store["arp_ctx"] api.Trigger(arpReqs) #Spread CPS evenly clientReq = api.Trigger_CreateAllParallelCommandsRequest() clientPcapReq = api.Trigger_CreateAllParallelCommandsRequest() cps_per_node = int(cps / len(store["client_ctxts"])) for index, (_, client) in enumerate(store["client_ctxts"].items()): jsonInput = {"connections": []} for serverIPPort in client.GetServers(): jsonInput["connections"].append({ "ServerIPPort": serverIPPort, "proto": "tcp" }) outfile = api.GetTestDataDirectory( ) + "/" + client.workload_name + "_fuz.json" with open(outfile, 'w') as fp: json.dump(jsonInput, fp) api.CopyToWorkload(client.node_name, client.workload_name, [outfile], "") api.Trigger_AddCommand(clientPcapReq, client.node_name, client.workload_name, "tcpdump -i eth1 -w %s.pcap" % (client.workload_name), background=True) clientCmd = fuz_init.FUZ_EXEC[ client. workload_name] + " -attempts 6 -duration " + session_time + " -conns " + str( sessions) + " -cps " + str( cps_per_node ) + " -talk --jsonOut --jsonInput " + os.path.basename( outfile) api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, clientCmd, timeout=0) if pcap_capture: #Start Server Pcap serverPcapReq = api.Trigger_CreateAllParallelCommandsRequest() for pcap_info in store["server_pcap_info"]: node_name, intf, pcap_file = pcap_info[0], pcap_info[1], pcap_info[ 2] api.Trigger_AddHostCommand(serverPcapReq, node_name, "tcpdump -i %s -w %s" % (intf, pcap_file), background=True) tc.server_pcap_resp = api.Trigger(serverPcapReq) tc.fuz_client_pcap_resp = api.Trigger(clientPcapReq) #Initiate connections tc.fuz_client_resp = api.Trigger(clientReq) if pcap_capture: #Stop tcpdump api.Trigger_TerminateAllCommands(tc.fuz_client_pcap_resp) api.Trigger_TerminateAllCommands(tc.server_pcap_resp) for _, client in store["client_ctxts"].items(): api.CopyFromWorkload(client.node_name, client.workload_name, [client.workload_name + ".pcap"], tc.GetLogsDir()) #Stop server Pcaps too #for pcap_info in store["server_pcap_info"]: # node_name, intf, pcap_file = pcap_info[0], pcap_info[1], pcap_info[2] # api.CopyFromHost(node_name, [pcap_file], tc.GetLogsDir()) return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() server = pairs[0][0] client = pairs[0][1] tc.cmd_cookies = [] tc.controlageout_fail = 0 naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS req = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr)) dir_path = os.path.dirname(os.path.realpath(__file__)) fullpath = dir_path + '/' + "small.vob" api.Logger.info("fullpath %s" % (fullpath)) resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir') if resp is None: return api.types.status.FAILURE api.Trigger_AddCommand(req, client.node_name, client.workload_name, "ls -al | grep video") tc.cmd_cookies.append("Before RTSP") api.Trigger_AddCommand(req, server.node_name, server.workload_name, "ip route del 224.0.0.0/4") tc.cmd_cookies.append("ip route del server") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "ip route del 224.0.0.0/4") tc.cmd_cookies.append("ip route del client") api.Trigger_AddCommand( req, server.node_name, server.workload_name, "ip route add 224.0.0.0/4 dev %s" % (server.interface)) tc.cmd_cookies.append("ip route server") server_cmd = "cd rtspdir && vobStreamer -p 2004 small.vob" api.Trigger_AddCommand(req, server.node_name, server.workload_name, server_cmd, background=True, timeout=300) tc.cmd_cookies.append("Run RTSP server") api.Trigger_AddCommand( req, client.node_name, client.workload_name, "ip route add 224.0.0.0/4 dev %s" % (client.interface)) tc.cmd_cookies.append("ip route client") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "openRTSP rtsp://%s:2004/vobStream" % (server.ip_address), timeout=300) tc.cmd_cookies.append("Run RTSP client") ## Add Naples command validation api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --alg rtsp --yaml") tc.cmd_cookies.append("show session RTSP established") api.Trigger_AddNaplesCommand(req, naples.node_name, "sleep 30", timeout=300) tc.cmd_cookies.append("sleep") api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --alg rtsp --yaml") tc.cmd_cookies.append("show yaml") trig_resp = api.Trigger(req) control_seen = 0 data_seen = 0 cmd = trig_resp.commands[-1] api.PrintCommandResults(cmd) alginfo = get_alginfo(cmd, APP_SVC_RTSP) for info in alginfo: if info['rtspinfo']['iscontrol'] == True: control_seen = 1 if info['rtspinfo']['iscontrol'] == False: data_seen = 1 if control_seen == 0 and data_seen == 1: tc.controlageout_fail = 1 term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() server = pairs[0][0] client = pairs[0][1] tc.cmd_cookies = [] tc.memleak = 0 naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr)) dir_path = os.path.dirname(os.path.realpath(__file__)) fullpath = dir_path + '/' + "small.vob" api.Logger.info("fullpath %s" % (fullpath)) resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir') if resp is None: return api.types.status.FAILURE memreq = api.Trigger_CreateExecuteCommandsRequest(serial = True) api.Trigger_AddNaplesCommand(memreq, naples.node_name, "/nic/bin/halctl clear session") api.Trigger_AddNaplesCommand(memreq, naples.node_name, "/nic/bin/halctl show system memory slab --yaml") mem_trig_resp = api.Trigger(memreq) cmd = mem_trig_resp.commands[-1] for command in mem_trig_resp.commands: api.PrintCommandResults(command) meminfo = get_meminfo(cmd, 'rtsp') for info in meminfo: if (info['inuse'] != 0 or info['allocs'] != info['frees']): tc.memleak = 1 mem_term_resp = api.Trigger_TerminateAllCommands(mem_trig_resp) mem_resp = api.Trigger_AggregateCommandsResponse(mem_trig_resp, mem_term_resp) req = api.Trigger_CreateExecuteCommandsRequest(serial = True) server_cmd = "cd rtspdir && live555MediaServer" api.Trigger_AddCommand(req, server.node_name, server.workload_name, server_cmd, background = True) tc.cmd_cookies.append("Run RTSP server") for cnt in range(tc.args.count): api.Trigger_AddCommand(req, client.node_name, client.workload_name, "openRTSP rtsp://%s/small.vob" % server.ip_address) tc.cmd_cookies.append("Run RTSP client") ## Add Naples command validation api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg rtsp") tc.cmd_cookies.append("show session RTSP established") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate | grep RTSP") tc.cmd_cookies.append("show flow-gate") api.Trigger_AddNaplesCommand(req, naples.node_name, "sleep 250", timeout=300) tc.cmd_cookies.append("sleep") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg rtsp") tc.cmd_cookies.append("show session RTSP established") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show system memory slab --yaml") tc.cmd_cookies.append("show memory slab") trig_resp = api.Trigger(req) cmd = trig_resp.commands[-1] meminfo_after = get_meminfo(cmd, 'rtsp') for idx in range(0, len(meminfo)): if (meminfo[idx]['inuse'] != meminfo_after[idx]['inuse'] or \ meminfo_after[idx]['allocs'] != meminfo_after[idx]['frees']): tc.memleak = 1 term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): if tc.local_or_remote == "local": pairs = api.GetLocalWorkloadPairs() else: pairs = api.GetRemoteWorkloadPairs() if not len(pairs): return api.types.status.FAILURE server = pairs[0][0] client = pairs[0][1] if tc.node_to_move == "client": tc.vm_node = client else: tc.vm_node = server vm_utils.get_vm_dbg_stats(tc) tc.cmd_cookies = [] serverReq = None clientReq = None serverReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) clientReq = api.Trigger_CreateExecuteCommandsRequest(serial=False) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr)) dir_path = os.path.dirname(os.path.realpath(__file__)) fullpath = dir_path + '/' + "sample.vob" resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir') if resp is None: return api.types.status.FAILURE api.Trigger_AddCommand(serverReq, server.node_name, server.workload_name, "cd rtspdir && live555MediaServer", background=True) tc.cmd_cookies.append("Run RTSP server") api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name, "openRTSP rtsp://%s/sample.vob" % server.ip_address) tc.cmd_cookies.append("Run RTSP client") # Trigger the commands tc.server_resp = api.Trigger(serverReq) tc.client_resp = api.Trigger(clientReq) tc.resp = api.Trigger_AggregateCommandsResponse(tc.server_resp, tc.client_resp) # Trigger vMotion new_node = vm_utils.find_new_node_to_move_to(tc, tc.vm_node) vm_utils.update_move_info(tc, [tc.vm_node], False, new_node) vm_utils.do_vmotion(tc, True) vm_utils.update_node_info(tc, tc.client_resp) # After vMotion - Wait for Commands to end tc.client_resp = api.Trigger_WaitForAllCommands(tc.client_resp) api.Trigger_TerminateAllCommands(tc.server_resp) # After vMotion - Show sessions dump after vMotion tc.cmd_cookies = [] req = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddNaplesCommand( req, tc.vm_node.node_name, "/nic/bin/halctl show session --alg rtsp --yaml") tc.cmd_cookies.append("show session RTSP") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): triplet = GetThreeWorkloads() server = triplet[0][0] client1 = triplet[0][1] client2 = triplet[0][2] tc.cmd_cookies = [] naples = server if not server.IsNaples(): naples = client1 if not client1.IsNaples(): naples = client2 if not client2.IsNaples(): return api.types.status.SUCCESS req = api.Trigger_CreateExecuteCommandsRequest(serial = True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client1.workload_name, client1.ip_address) api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr)) dir_path = os.path.dirname(os.path.realpath(__file__)) fullpath = dir_path + '/' + "small.vob" api.Logger.info("fullpath %s" % (fullpath)) resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir') if resp is None: return api.types.status.FAILURE api.Trigger_AddCommand(req, client1.node_name, client1.workload_name, "ls -al | grep video") tc.cmd_cookies.append("Before RTSP") server_cmd = "cd rtspdir && vobStreamer -p 2004 small.vob" api.Trigger_AddCommand(req, server.node_name, server.workload_name, server_cmd, background = True) tc.cmd_cookies.append("Run RTSP server") api.Trigger_AddCommand(req, client1.node_name, client1.workload_name, "openRTSP rtsp://%s:2004/vobStream" % server.ip_address) tc.cmd_cookies.append("Run RTSP client1") ## Add Naples command validation api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg rtsp") tc.cmd_cookies.append("show session RTSP established") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate | grep RTSP") tc.cmd_cookies.append("show flow-gate") api.Trigger_AddCommand(req, client1.node_name, client1.workload_name, "ls -al | grep video") tc.cmd_cookies.append("After RTSP") trig_resp = api.Trigger(req) dest = trig_resp.commands[2].stdout.find("Transport: RTP/AVP;multicast;destination=") dest += 41 ip = trig_resp.commands[2].stdout[dest:dest+35] end = ip.find(";") req2 = api.Trigger_CreateExecuteCommandsRequest(serial = True) api.Trigger_AddCommand(req2, client2.node_name, client2.workload_name, "ip route add 224.0.0.0/4 dev %s"%(client2.interface), background = True) tc.cmd_cookies.append("ip route client2") api.Trigger_AddCommand(req2, client2.node_name, client2.workload_name, "sed -i 's/geteuid/getppid/' /usr/bin/vlc && cvlc -vvv rtp://%s:8888 --start-time=00 --run-time=5" % ip[0:end]) tc.cmd_cookies.append("Run RTP client2") api.Trigger_AddNaplesCommand(req2, naples.node_name, "/nic/bin/halctl show session --srcip %s "%(client2.ip_address)) tc.cmd_cookies.append("show session RTP") trig_resp2 = api.Trigger(req2) term_resp2 = api.Trigger_TerminateAllCommands(trig_resp2) tc.resp2 = api.Trigger_AggregateCommandsResponse(trig_resp2, term_resp2) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) ForceReleasePort("554/tcp", server) ForceReleasePort("554/tcp", client1) ForceReleasePort("554/tcp", client2) return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() server = pairs[0][0] client = pairs[0][1] tc.cmd_cookies = [] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS req = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting MSRPC test from %s" % (tc.cmd_descr)) api.Trigger_AddCommand(req, server.node_name, server.workload_name, "tcpdump -nni %s > out.txt" % (server.interface), background=True) tc.cmd_cookies.append("tcpdump") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "tcpdump -nni %s > out.txt" % (client.interface), background=True) tc.cmd_cookies.append("tcpdump") api.Trigger_AddCommand(req, server.node_name, server.workload_name, "sudo nc -l %s" % (MSRPC_PORT), background=True) tc.cmd_cookies.append("netcat start-server") client_port = api.AllocateTcpPort() api.Trigger_AddCommand(req, client.node_name, client.workload_name, "sudo nc %s %s -p %s" % (server.ip_address, MSRPC_PORT, client_port), background=True) tc.cmd_cookies.append("netcat start-client") msrpcscript = dir_path + '/' + "msrpcscapy.py" resp = api.CopyToWorkload(server.node_name, server.workload_name, [msrpcscript], 'msrpcdir') if resp is None: return api.types.status.SUCCESS resp = api.CopyToWorkload(client.node_name, client.workload_name, [msrpcscript], 'msrpcdir') if resp is None: return api.types.status.SUCCESS api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --dstport 135 --yaml") tc.cmd_cookies.append("show session yaml") sesssetup = api.Trigger(req) cmd = sesssetup.commands[-1] api.PrintCommandResults(cmd) tc.pre_ctrckinf = get_conntrackinfo(cmd) req = api.Trigger_CreateExecuteCommandsRequest(serial=True) msrpcpcap = dir_path + '/' + "msrpc_first_bind.pcap" pkts = rdpcap(msrpcpcap) clientidx = 0 serveridx = 0 client_ack = tc.pre_ctrckinf.i_tcpacknum server_ack = tc.pre_ctrckinf.r_tcpacknum filename = None for pkt in pkts: node = client.node_name workload = client.workload_name if pkt[IP].src == "172.31.9.1": filename = ("msrpcscapy" + "%s" + ".pcap") % (clientidx) msrpcscapy = dir_path + '/' + filename pkt[Ether].src = client.mac_address pkt[IP].src = client.ip_address pkt[Ether].dst = server.mac_address pkt[IP].dst = server.ip_address pkt[TCP].sport = client_port pkt[TCP].dport = 135 if clientidx == 0: client_start_seq = pkt[TCP].seq client_start_ack = pkt[TCP].ack pkt[TCP].seq = tc.pre_ctrckinf.i_tcpseqnum + (pkt[TCP].seq - client_start_seq) pkt[TCP].ack = client_ack server_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1 clientidx += 1 else: filename = ("msrpcscapy" + "%s" + ".pcap") % (serveridx) msrpcscapy = dir_path + '/' + filename pkt[Ether].src = server.mac_address pkt[IP].src = server.ip_address pkt[Ether].dst = client.mac_address pkt[IP].dst = client.ip_address node = server.node_name workload = server.workload_name pkt[TCP].dport = client_port pkt[TCP].sport = 135 if serveridx == 0: server_start_seq = pkt[TCP].seq server_start_ack = pkt[TCP].ack pkt[TCP].seq = tc.pre_ctrckinf.r_tcpseqnum + (pkt[TCP].seq - server_start_seq) pkt[TCP].ack = server_ack client_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1 serveridx += 1 del pkt[IP].chksum del pkt[TCP].chksum a = pkt.show(dump=True) print(a) wrpcap(msrpcscapy, pkt) resp = api.CopyToWorkload(node, workload, [msrpcscapy], 'msrpcdir') if resp is None: continue api.Trigger_AddCommand( req, node, workload, "sh -c 'cd msrpcdir && chmod +x msrpcscapy.py && ./msrpcscapy.py %s'" % (filename)) tc.cmd_cookies.append("running #%s on node %s workload %s" % (filename, node, workload)) os.remove(msrpcscapy) api.Trigger_AddNaplesCommand( req, naples.node_name, "/nic/bin/halctl show session --dstport 135 --yaml") tc.cmd_cookies.append("show session yaml") firstbind = api.Trigger(req) cmd = firstbind.commands[-1] api.PrintCommandResults(cmd) tc.post_ctrckinf = get_conntrackinfo(cmd) req = api.Trigger_CreateExecuteCommandsRequest(serial=True) msrpcpcap = dir_path + '/' + "msrpc_second_bind.pcap" pkts = rdpcap(msrpcpcap) client_ack = tc.post_ctrckinf.i_tcpacknum server_ack = tc.post_ctrckinf.r_tcpacknum clientidx = 0 serveridx = 0 filename = None for pkt in pkts: node = client.node_name workload = client.workload_name if pkt[IP].src == "172.31.9.1": filename = ("msrpcscapy" + "%s" + ".pcap") % (clientidx) msrpcscapy = dir_path + '/' + filename pkt[Ether].src = client.mac_address pkt[IP].src = client.ip_address pkt[Ether].dst = server.mac_address pkt[IP].dst = server.ip_address pkt[TCP].sport = client_port pkt[TCP].dport = 135 if clientidx == 0: client_start_seq = pkt[TCP].seq client_start_ack = pkt[TCP].ack pkt[TCP].seq = tc.post_ctrckinf.i_tcpseqnum + (pkt[TCP].seq - client_start_seq) pkt[TCP].ack = client_ack server_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1 clientidx += 1 else: filename = ("msrpcscapy" + "%s" + ".pcap") % (serveridx) msrpcscapy = dir_path + '/' + filename pkt[Ether].src = server.mac_address pkt[IP].src = server.ip_address pkt[Ether].dst = client.mac_address pkt[IP].dst = client.ip_address node = server.node_name workload = server.workload_name pkt[TCP].dport = client_port pkt[TCP].sport = 135 if serveridx == 0: server_start_seq = pkt[TCP].seq server_start_ack = pkt[TCP].ack pkt[TCP].seq = tc.post_ctrckinf.r_tcpseqnum + (pkt[TCP].seq - server_start_seq) pkt[TCP].ack = server_ack client_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1 serveridx += 1 del pkt[IP].chksum del pkt[TCP].chksum a = pkt.show(dump=True) print(a) wrpcap(msrpcscapy, pkt) resp = api.CopyToWorkload(node, workload, [msrpcscapy], 'msrpcdir') if resp is None: continue api.Trigger_AddCommand( req, node, workload, "sh -c 'cd msrpcdir && chmod +x msrpcscapy.py && ./msrpcscapy.py %s'" % (filename)) tc.cmd_cookies.append("running #%s on node %s workload %s" % (filename, node, workload)) os.remove(msrpcscapy) api.Trigger_AddCommand(req, server.node_name, server.workload_name, "sudo nc -l 49134", background=True) tc.cmd_cookies.append("msrpc start-server") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "sudo nc %s 49134 -p 59374" % (server.ip_address), background=True) tc.cmd_cookies.append("msrpc start-client") # Add Naples command validation #api.Trigger_AddNaplesCommand(req, naples.node_name, # "/nic/bin/halctl show security flow-gate | grep MSRPC") #tc.cmd_cookies.append("show security flow-gate") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session") tc.cmd_cookies.append("show session") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp2 = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) term_resp = api.Trigger_TerminateAllCommands(firstbind) tc.resp1 = api.Trigger_AggregateCommandsResponse(firstbind, term_resp) term_resp = api.Trigger_TerminateAllCommands(sesssetup) tc.resp = api.Trigger_AggregateCommandsResponse(sesssetup, term_resp) #GetTcpdumpData(client) #GetTcpdumpData(server) return api.types.status.SUCCESS
def SetupFTPServer(node, workload, promiscous=False, bind_fail=False, listen_port=FTP_STANDARD_PORT, restart=True): ftpdata = dir_path + '/' + "ftp_server.txt" api.Logger.info("fullpath %s" % (ftpdata)) resp = api.CopyToWorkload(node, workload, [ftpdata], 'ftpdir') if resp is None: return None if promiscous == True: if bind_fail == True: vsftpd_file = "lftp_vsftpd_bind_fail.conf" vsftpd_conf = dir_path + '/' + "lftp_vsftpd_bind_fail.conf" else: vsftpd_file = "lftp_vsftpd.conf" vsftpd_conf = dir_path + '/' + "lftp_vsftpd.conf" else: vsftpd_file = "vsftpd.conf" vsftpd_conf = dir_path + '/' + "vsftpd.conf" resp = api.CopyToWorkload(node, workload, [vsftpd_conf], 'ftpdir') if resp is None: return None req = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddCommand( req, node, workload, "cp ftpdir/%s /etc/vsftpd/vsftpd.conf" % (vsftpd_file)) if listen_port != FTP_STANDARD_PORT: api.Trigger_AddCommand( req, node, workload, "echo \"listen_port=%d\" | tee -a /etc/vsftpd/vsftpd.conf" % (listen_port)) api.Trigger_AddCommand(req, node, workload, "useradd -m -c \"admin\" -s /bin/bash admin") api.Trigger_AddCommand(req, node, workload, "useradd -m -c \"admin1\" -s /bin/bash admin1") api.Trigger_AddCommand(req, node, workload, "echo \"admin\" | tee -a /etc/vsftpd.userlist") api.Trigger_AddCommand(req, node, workload, "echo \"admin1\" | tee -a /etc/vsftpd.userlist") api.Trigger_AddCommand(req, node, workload, "echo \"linuxpassword\" | passwd --stdin admin") api.Trigger_AddCommand(req, node, workload, "echo \"docker\" | passwd --stdin admin1") api.Trigger_AddCommand(req, node, workload, "echo \"docker\" | passwd --stdin admin1") api.Trigger_AddCommand( req, node, workload, "mkdir /home/admin/ftp && mv ftpdir/ftp_server.txt /home/admin/ftp") api.Trigger_AddCommand( req, node, workload, "touch /home/admin/ftp/ftp_client.txt && chmod 666 /home/admin/ftp/ftp_client.txt" ) if restart == True: api.Trigger_AddCommand(req, node, workload, "systemctl stop vsftpd") api.Trigger_AddCommand(req, node, workload, "systemctl start vsftpd") api.Trigger_AddCommand(req, node, workload, "systemctl enable vsftpd") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) for cmd in trig_resp.commands: api.PrintCommandResults(cmd) return api.types.status.SUCCESS