def test_ecmp_bw_three_vms_same_fip_incr_sport(self): """ Description: Test communication between three VMs who have borrowed the FIP from common FIP pool. Increment sport and have 3 flows setup. Test steps: 1. Test communication between three VMs who have borrowed the FIP from common FIP pool. 2. Sending 3 different streams with incrementing sports. 3. Check the route table for the FIP address which should indicate ECMP. Pass criteria: Traffic should reach the other VMs from vm1. Maintainer : [email protected] """ self.setup_common_objects() vm_list = [self.vm1, self.vm2, self.vm3] stream1 = Stream(protocol="ip", proto="udp", src=self.fvn_vm1.vm_ip, dst=self.my_fip, sport=unicode(8000), dport=self.dport1) stream2 = Stream(protocol="ip", proto="udp", src=self.fvn_vm1.vm_ip, dst=self.my_fip, sport=unicode(11000), dport=self.dport1) stream3 = Stream(protocol="ip", proto="udp", src=self.fvn_vm1.vm_ip, dst=self.my_fip, sport=unicode(12000), dport=self.dport1) stream_list = [stream1, stream2, stream3] self.sender, self.receiver = self.start_traffic( self.fvn_vm1, vm_list, stream_list, self.fvn_vm1.vm_ip, self.my_fip) self.logger.info('Sending traffic for 10 seconds') time.sleep(10) self.verify_flow_records(self.fvn_vm1, self.fvn_vm1.vm_ip, self.my_fip) return True
def setup_and_create_streams(self, src_vn_fix, dst_vn_fix, src_vm_fix, dst_vm_fix, sport=8000, dport=9000, count=100): src_vm_node_ip = src_vm_fix.vm_node_ip dst_vm_node_ip = dst_vm_fix.vm_node_ip src_local_host = Host( src_vm_node_ip, self.inputs.host_data[src_vm_node_ip]['username'], self.inputs.host_data[dst_vm_node_ip]['password']) dst_local_host = Host( dst_vm_node_ip, self.inputs.host_data[dst_vm_node_ip]['username'], self.inputs.host_data[dst_vm_node_ip]['password']) send_host = Host(src_vm_fix.local_ip, src_vm_fix.vm_username, src_vm_fix.vm_password) recv_host = Host(dst_vm_fix.local_ip, dst_vm_fix.vm_username, dst_vm_fix.vm_password) send_file_name = 'sendudp' recv_file_name = 'recvudp' # Create traffic stream for i in range(3): sport = sport dport = dport + i print 'count=%s' % (count) print 'dport=%s' % (dport) self.logger.info("Creating streams...") stream = Stream(protocol="ip", proto='udp', src=src_vm_fix.vm_ip, dst=dst_vm_fix.vm_ip, dport=dport, sport=sport) profile = StandardProfile(stream=stream, size=100, count=count, listener=dst_vm_fix.vm_ip) sender = Sender(send_file_name, profile, src_local_host, send_host, self.inputs.logger) receiver = Receiver(recv_file_name, profile, dst_local_host, recv_host, self.inputs.logger) receiver.start() sender.start() sender.stop() receiver.stop() print sender.sent, receiver.recv time.sleep(1)
def start_traffic(self): # installing traffic package in vm self.vn1_vm1_fixture.install_pkg("Traffic") self.vn2_vm2_fixture.install_pkg("Traffic") self.fvn_vm1_fixture.install_pkg("Traffic") self.tx_vm_node_ip = self.vn1_vm1_fixture.vm_node_ip self.rx_vm_node_ip = self.vn2_vm2_fixture.vm_node_ip self.tx_local_host = Host( self.tx_vm_node_ip, self.inputs.host_data[ self.tx_vm_node_ip]['username'], self.inputs.host_data[ self.tx_vm_node_ip]['password']) self.rx_local_host = Host( self.rx_vm_node_ip, self.inputs.host_data[ self.rx_vm_node_ip]['username'], self.inputs.host_data[ self.rx_vm_node_ip]['password']) self.send_host = Host(self.vn1_vm1_fixture.local_ip, self.vn1_vm1_fixture.vm_username, self.vn1_vm1_fixture.vm_password) self.recv_host = Host(self.vn2_vm2_fixture.local_ip, self.vn2_vm2_fixture.vm_username, self.vn2_vm2_fixture.vm_password) # Create traffic stream self.logger.info("Creating streams...") stream = Stream( protocol="ip", proto="udp", src=self.vn1_vm1_fixture.vm_ip, dst=self.vn2_vm2_fixture.vm_ip, dport=9000) profile = StandardProfile( stream=stream, size=100, count=10, listener=self.vn2_vm2_fixture.vm_ip) self.sender = Sender( "sendudp", profile, self.tx_local_host, self.send_host, self.inputs.logger) self.receiver = Receiver( "recvudp", profile, self.rx_local_host, self.recv_host, self.inputs.logger) self.receiver.start() self.sender.start() time.sleep(10)
def setup_streams(self, src_vm, dst_vm_list, src_ip=None, dst_ip=None, flow_count=3): src_ip = src_vm.vm_ip if dst_ip == None: dst_ip = dst_vm_list[0].vm_ip stream_list=[] for i in range(0,flow_count): stream_name = "stream"+str(i+1) dport = 9000+i stream_name = Stream(proto="udp", src=src_ip, dst=dst_ip, sport=8000, dport=dport) stream_list.append(stream_name) return stream_list
def setup_streams(self, src_vm, dst_vm_list, src_ip=None, dst_ip=None): src_ip = src_vm.vm_ip if dst_ip == None: dst_ip = dst_vm_list[0].vm_ip stream1 = Stream(proto="udp", src=src_ip, dst=dst_ip, sport=8000, dport=9000) stream2 = Stream(proto="udp", src=src_ip, dst=dst_ip, sport=8000, dport=9001) stream3 = Stream(proto="udp", src=src_ip, dst=dst_ip, sport=8000, dport=9002) stream_list = [stream1, stream2, stream3] return stream_list
def start_traffic_scapy(self, sender_vm, receiver_vm, proto, sport, dport, count=None, fip=None, payload=None, icmp_type=None, icmp_code=None, recvr=True): # Create stream and profile if fip: stream = Stream(protocol="ip", sport=sport, dport=dport, proto=proto, src=sender_vm.vm_ip, dst=fip, type=icmp_type, code=icmp_code) else: stream = Stream(protocol="ip", sport=sport, dport=dport, proto=proto, src=sender_vm.vm_ip, dst=receiver_vm.vm_ip, type=icmp_type, code=icmp_code) profile_kwargs = {'stream': stream} if fip: profile_kwargs.update({'listener': receiver_vm.vm_ip}) if payload: profile_kwargs.update({'payload': payload}) if count: profile_kwargs.update({'count': count}) profile = StandardProfile(**profile_kwargs) else: profile = ContinuousProfile(**profile_kwargs) # Set VM credentials send_node = Host(sender_vm.vm_node_ip, self.inputs.username, self.inputs.password) recv_node = Host(receiver_vm.vm_node_ip, self.inputs.username, self.inputs.password) send_host = Host(sender_vm.local_ip, sender_vm.vm_username, sender_vm.vm_password) recv_host = Host(receiver_vm.local_ip, receiver_vm.vm_username, receiver_vm.vm_password) # Create send, receive helpers sender = Sender("send%s" % proto, profile, send_node, send_host, self.inputs.logger) receiver = Receiver("recv%s" % proto, profile, recv_node, recv_host, self.inputs.logger) # start traffic if recvr: receiver.start() sender.start() return (sender, receiver)
def test_traffic_connections_while_control_nodes_go_down(self): """Tests related to connections and traffic while switching from normal mode to headless and back i.e. control nodes go down and come online.""" if len(self.inputs.compute_ips) < 2: raise unittest.SkipTest("This test needs atleast 2 compute nodes.") else: self.logger.info( "Required resources are in place to run the test.") result = True topology_class_name = None self.compute_fixture_dict = {} for each_compute in self.inputs.compute_ips: self.compute_fixture_dict[each_compute] = self.useFixture( ComputeNodeFixture(connections=self.connections, node_ip=each_compute, username=self.inputs.username, password=self.inputs.password)) mode = self.compute_fixture_dict[ each_compute].get_agent_headless_mode() if mode is False: self.compute_fixture_dict[ each_compute].set_agent_headless_mode() # # Get config for test from topology result = True msg = [] if not topology_class_name: topology_class_name = test_headless_vrouter_topo.sdn_headless_vrouter_topo self.logger.info("Scenario for the test used is: %s" % (topology_class_name)) # # Create a list of compute node IP's and pass it to topo if you want to pin # a vm to a particular node topo_obj = topology_class_name( compute_node_list=self.inputs.compute_ips) # # Test setup: Configure policy, VN, & VM # return {'result':result, 'msg': err_msg, 'data': [self.topo, config_topo]} # Returned topo is of following format: # config_topo= {'policy': policy_fixt, 'vn': vn_fixture, 'vm': vm_fixture} topo = {} topo_objs = {} config_topo = {} setup_obj = self.useFixture( sdnTopoSetupFixture(self.connections, topo_obj)) out = setup_obj.sdn_topo_setup() self.assertEqual(out['result'], True, out['msg']) if out['result']: topo_objs, config_topo, vm_fip_info = out['data'] # Start Test proj = config_topo.keys() vms = config_topo[proj[0]]['vm'].keys() src_vm = config_topo[proj[0]]['vm'][vms[0]] dest_vm = config_topo[proj[0]]['vm'][vms[1]] flow_cache_timeout = 180 # Setup Traffic. stream = Stream(protocol="ip", proto="icmp", src=src_vm.vm_ip, dst=dest_vm.vm_ip) profile = ContinuousProfile(stream=stream, count=0, capfilter="icmp") tx_vm_node_ip = src_vm.vm_node_ip rx_vm_node_ip = dest_vm.vm_node_ip tx_local_host = Host(tx_vm_node_ip, self.inputs.username, self.inputs.password) rx_local_host = Host(rx_vm_node_ip, self.inputs.username, self.inputs.password) send_host = Host(src_vm.local_ip, src_vm.vm_username, src_vm.vm_password) recv_host = Host(dest_vm.local_ip, dest_vm.vm_username, dest_vm.vm_password) sender = Sender("icmp", profile, tx_local_host, send_host, self.inputs.logger) receiver = Receiver("icmp", profile, rx_local_host, recv_host, self.inputs.logger) receiver.start() sender.start() self.logger.info("Waiting for 5 sec for traffic to be setup ...") time.sleep(5) flow_index_list = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) headless_vr_utils.stop_all_control_services(self) self.addCleanup(self.inputs.start_service, 'contrail-control', self.inputs.bgp_ips, container='control') headless_vr_utils.check_through_tcpdump(self, dest_vm, src_vm) flow_index_list2 = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) if flow_index_list == flow_index_list2: self.logger.info("Flow indexes have not changed.") else: self.logger.error( "Flow indexes have changed. Test Failed, Exiting") return False # wait_for_flow_cache_timeout time.sleep(flow_cache_timeout) # verify_flow_is_not_recreated flow_index_list = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) if flow_index_list == flow_index_list2: self.logger.info("Flow indexes have not changed.") else: self.logger.error( "Flow indexes have changed. Test Failed, Exiting") return False receiver.stop() sender.stop() # wait_for_flow_cache_timeout time.sleep(flow_cache_timeout + 5) # verify_flow_is_cleared flow_index_list = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) if not len(flow_index_list): self.logger.info("No flows are present") else: self.logger.error("Flows are still present.") return False # start_ping receiver.start() sender.start() self.logger.info("Waiting for 5 sec for traffic to be setup ...") time.sleep(5) # verify_flow_is_recreated flow_index_list = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) if (flow_index_list[0] and flow_index_list[1]): self.logger.info("Flows are recreated.") else: self.logger.error("Flows are still absent.") return False headless_vr_utils.start_all_control_services(self) headless_vr_utils.check_through_tcpdump(self, dest_vm, src_vm) # wait_for_flow_cache_timeout time.sleep(flow_cache_timeout + 5) flow_index_list2 = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) if flow_index_list == flow_index_list2: self.logger.info("Flow indexes have not changed.") else: self.logger.error( "Flow indexes have changed. Test Failed, Exiting") return False receiver.stop() sender.stop() # wait_for_flow_cache_timeout time.sleep(flow_cache_timeout + 5) # verify_flow_is_cleared flow_index_list = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) if not len(flow_index_list): self.logger.info("No flows are present") else: self.logger.error("Flows are still present.") return False # start_ping receiver.start() sender.start() self.logger.info("Waiting for 5 sec for traffic to be setup ...") time.sleep(5) # verify_flow_is_recreated flow_index_list = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) if (flow_index_list[0] and flow_index_list[1]): self.logger.info("Flows are recreated.") else: self.logger.error("Flows are still absent.") return False receiver.stop() sender.stop() return True
def test_config_add_change_while_control_nodes_go_down(self): """Tests related to configuration add, change, and delete while switching from normal mode to headless and back i.e. control nodes go down and come online.""" if len(self.inputs.compute_ips) < 2: raise unittest.SkipTest("This test needs atleast 2 compute nodes.") else: self.logger.info( "Required resources are in place to run the test.") result = True topology_class_name = None self.compute_fixture_dict = {} for each_compute in self.inputs.compute_ips: self.compute_fixture_dict[each_compute] = self.useFixture( ComputeNodeFixture(connections=self.connections, node_ip=each_compute, username=self.inputs.username, password=self.inputs.password)) mode = self.compute_fixture_dict[ each_compute].get_agent_headless_mode() if mode is False: self.compute_fixture_dict[ each_compute].set_agent_headless_mode() # # Get config for test from topology result = True msg = [] if not topology_class_name: topology_class_name = test_headless_vrouter_topo.sdn_headless_vrouter_topo self.logger.info("Scenario for the test used is: %s" % (topology_class_name)) # # Create a list of compute node IP's and pass it to topo if you want to pin # a vm to a particular node topo_obj = topology_class_name( compute_node_list=self.inputs.compute_ips) # # Test setup: Configure policy, VN, & VM # return {'result':result, 'msg': err_msg, 'data': [self.topo, config_topo]} # Returned topo is of following format: # config_topo= {'policy': policy_fixt, 'vn': vn_fixture, 'vm': vm_fixture} topo = {} topo_objs = {} config_topo = {} setup_obj = self.useFixture( sdnTopoSetupFixture(self.connections, topo_obj)) out = setup_obj.sdn_topo_setup() self.assertEqual(out['result'], True, out['msg']) if out['result']: topo_objs, config_topo, vm_fip_info = out['data'] # Start Test proj = config_topo.keys() vms = config_topo[proj[0]]['vm'].keys() src_vm = config_topo[proj[0]]['vm'][vms[0]] dest_vm = config_topo[proj[0]]['vm'][vms[1]] flow_cache_timeout = 180 # Setup Traffic. stream = Stream(protocol="ip", proto="icmp", src=src_vm.vm_ip, dst=dest_vm.vm_ip) profile = ContinuousProfile(stream=stream, count=0, capfilter="icmp") tx_vm_node_ip = src_vm.vm_node_ip rx_vm_node_ip = dest_vm.vm_node_ip tx_local_host = Host(tx_vm_node_ip, self.inputs.username, self.inputs.password) rx_local_host = Host(rx_vm_node_ip, self.inputs.username, self.inputs.password) send_host = Host(src_vm.local_ip, src_vm.vm_username, src_vm.vm_password) recv_host = Host(dest_vm.local_ip, dest_vm.vm_username, dest_vm.vm_password) sender = Sender("icmp", profile, tx_local_host, send_host, self.inputs.logger) receiver = Receiver("icmp", profile, rx_local_host, recv_host, self.inputs.logger) receiver.start() sender.start() self.logger.info("Waiting for 5 sec for traffic to be setup ...") time.sleep(5) #self.start_ping(src_vm, dest_vm) flow_index_list = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) headless_vr_utils.stop_all_control_services(self) self.addCleanup(self.inputs.start_service, 'contrail-control', self.inputs.bgp_ips, container='control') time.sleep(10) headless_vr_utils.check_through_tcpdump(self, dest_vm, src_vm) flow_index_list2 = headless_vr_utils.get_flow_index_list( self, src_vm, dest_vm) if set(flow_index_list) == set(flow_index_list2): self.logger.info("Flow indexes have not changed.") else: self.logger.error( "Flow indexes have changed. Test Failed, Exiting") return False receiver.stop() sender.stop() project1_instance = config_topo['project1']['project']['project1'] project1_instance.get_project_connections() vnet2_instance = config_topo['project1']['vn']['vnet2'] # add VM to existing VN VM22_fixture = self.useFixture( VMFixture( connections=project1_instance.project_connections['juniper'], vn_obj=vnet2_instance.obj, vm_name='VM22', project_name=project1_instance.project_name)) # create new IPAM ipam3_obj = self.useFixture( IPAMFixture(project_obj=project1_instance, name='ipam3')) ipam4_obj = self.useFixture( IPAMFixture(project_obj=project1_instance, name='ipam4')) # create new VN VN3_fixture = self.useFixture( VNFixture( project_name=project1_instance.project_name, connections=project1_instance.project_connections['juniper'], vn_name='VN3', inputs=project1_instance.inputs, subnets=['10.3.1.0/24'], ipam_fq_name=ipam3_obj.fq_name)) VN4_fixture = self.useFixture( VNFixture( project_name=project1_instance.project_name, connections=project1_instance.project_connections['juniper'], vn_name='VN4', inputs=project1_instance.inputs, subnets=['10.4.1.0/24'], ipam_fq_name=ipam4_obj.fq_name)) # create policy policy_name = 'policy34' rules = [] rules = [{ 'direction': '<>', 'protocol': 'icmp', 'dest_network': VN4_fixture.vn_fq_name, 'source_network': VN3_fixture.vn_fq_name, 'dst_ports': 'any', 'simple_action': 'pass', 'src_ports': 'any' }, { 'direction': '<>', 'protocol': 'icmp', 'dest_network': VN3_fixture.vn_fq_name, 'source_network': VN4_fixture.vn_fq_name, 'dst_ports': 'any', 'simple_action': 'pass', 'src_ports': 'any' }] policy34_fixture = self.useFixture( PolicyFixture( policy_name=policy_name, rules_list=rules, inputs=project1_instance.inputs, connections=project1_instance.project_connections['juniper'], project_fixture=project1_instance)) # create VN to policy mapping in a dict of policy list. vn_policys = { VN3_fixture.vn_name: [policy_name], VN4_fixture.vn_name: [policy_name] } # create a policy object list of policies to be attached to a vm policy_obj_dict = {} policy_obj_dict[VN3_fixture.vn_name] = [policy34_fixture.policy_obj] policy_obj_dict[VN4_fixture.vn_name] = [policy34_fixture.policy_obj] # vn fixture dictionary. vn_obj_dict = {} vn_obj_dict[VN3_fixture.vn_name] = VN3_fixture vn_obj_dict[VN4_fixture.vn_name] = VN4_fixture # attach policy to VN VN3_policy_fixture = self.useFixture( VN_Policy_Fixture( connections=project1_instance.project_connections['juniper'], vn_name=VN3_fixture.vn_name, policy_obj=policy_obj_dict, vn_obj=vn_obj_dict, vn_policys=vn_policys[VN3_fixture.vn_name], project_name=project1_instance.project_name)) VN4_policy_fixture = self.useFixture( VN_Policy_Fixture( connections=project1_instance.project_connections['juniper'], vn_name=VN4_fixture.vn_name, policy_obj=policy_obj_dict, vn_obj=vn_obj_dict, vn_policys=vn_policys[VN4_fixture.vn_name], project_name=project1_instance.project_name)) # add VM to new VN VM31_fixture = self.useFixture( VMFixture( connections=project1_instance.project_connections['juniper'], vn_obj=VN3_fixture.obj, vm_name='VM31', project_name=project1_instance.project_name)) VM41_fixture = self.useFixture( VMFixture( connections=project1_instance.project_connections['juniper'], vn_obj=VN4_fixture.obj, vm_name='VM41', project_name=project1_instance.project_name)) # verification routines. test_flag = 0 if ((VN3_fixture.verify_vn_in_api_server()) and (VN3_fixture.verify_vn_not_in_agent()) and (VN3_fixture.verify_vn_policy_in_api_server()['result'])): self.logger.info( "Verification of VN3 PASSED while control nodes down.") else: self.logger.error( "Verification of VN3 FAILED while control nodes down.") test_flag = 1 if ((VN4_fixture.verify_vn_in_api_server()) and (VN4_fixture.verify_vn_not_in_agent()) and (VN4_fixture.verify_vn_policy_in_api_server()['result'])): self.logger.info( "Verification of VN4 PASSED while control nodes down.") else: self.logger.error( "Verification of VN4 FAILED while control nodes down.") test_flag = 1 if ((VM22_fixture.verify_vm_launched()) and (VM22_fixture.verify_vm_in_api_server())): self.logger.info( "Verification of VM22 PASSED while control nodes down.") else: self.logger.error( "Verification of VM22 FAILED while control nodes down.") test_flag = 1 if ((VM31_fixture.verify_vm_launched()) and (VM31_fixture.verify_vm_in_api_server())): self.logger.info( "Verification of VM31 PASSED while control nodes down.") else: self.logger.error( "Verification of VM31 FAILED while control nodes down.") test_flag = 1 if ((VM41_fixture.verify_vm_launched()) and (VM41_fixture.verify_vm_in_api_server())): self.logger.info( "Verification of VM41 PASSED while control nodes down.") else: self.logger.error( "Verification of VM41 FAILED while control nodes down.") test_flag = 1 # start all control services. headless_vr_utils.start_all_control_services(self) # if something went wrong in the controller down state bail out here. if test_flag == 1: self.logger.error( "Verifications and Test failed while the controllers were down in \ headless state of agent. Check earlier error logs" ) return False # wait for 3 to 5 sec for configuration sync from control nodes to the # agents. time.sleep(5) # wait till VM's are up. VM22_fixture.wait_till_vm_is_up() VM31_fixture.wait_till_vm_is_up() VM41_fixture.wait_till_vm_is_up() # verify vm config gets downloaded to the agents. if ((VM22_fixture.verify_vm_in_agent()) and (VM31_fixture.verify_vm_in_agent()) and (VM41_fixture.verify_vm_in_agent())): self.logger.info("VM verification on the agent PASSED") else: self.logger.error("VM verification on the agent FAILED") return False # check ping success between the two VM's assert config_topo['project1']['vm']['VM11'].ping_with_certainty( VM22_fixture.vm_ip, expectation=True) assert VM31_fixture.ping_with_certainty(VM41_fixture.vm_ip, expectation=True) assert VM41_fixture.ping_with_certainty(VM31_fixture.vm_ip, expectation=True) # verification routines. if ((VN3_fixture.verify_on_setup()) and (VN4_fixture.verify_on_setup()) and (VM22_fixture.verify_on_setup()) and (VM31_fixture.verify_on_setup()) and (VM41_fixture.verify_on_setup())): self.logger.info( "All verifications passed after controllers came up in headless agent mode" ) else: self.logger.error( "Verifications FAILED after controllers came up in headless agent mode" ) return False return True
def test_ecmp_svc_in_network_with_3_instance_incr_dip(self): """ Description: Validate ECMP with service chaining in-network mode datapath having service instance. Send traffic to 3 different DIPs. Test steps: 1. Creating vm's - vm1 and vm2 in networks vn1 and vn2. 2. Creating a service instance in in-network-nat mode with 3 instances and left-interface of the service instances sharing the IP and enabled for static route. 3. Start traffic and send 3 different streams, one each to a DIP. 4. Creating a service chain by applying the service instance as a service in a policy b etween the VNs. 5. Checking for ping and tcp traffic between vm1 and vm2. Pass criteria: Ping between the VMs should be successful and TCP traffic should reach vm2 f rom vm1. Maintainer : [email protected] """ self.verify_svc_in_network_datapath(si_count=1, svc_scaling=True, max_inst=3) svm_ids = self.si_fixtures[0].svm_ids self.get_rt_info_tap_intf_list(self.vn1_fixture, self.vm1_fixture, self.vm2_fixture, svm_ids) dest_vm2 = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=self.vn2_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='dest_vm2')) assert dest_vm2.verify_on_setup() dest_vm3 = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=self.vn2_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='dest_vm3')) assert dest_vm3.verify_on_setup() vm_list = [self.vm1_fixture, self.vm2_fixture, dest_vm2, dest_vm3] for vm in vm_list: vm.install_pkg("Traffic") stream1 = Stream(protocol="ip", proto="udp", src=self.vm1_fixture.vm_ip, dst=self.vm2_fixture.vm_ip, sport=unicode(8000), dport=unicode(9000)) stream2 = Stream(protocol="ip", proto="udp", src=self.vm1_fixture.vm_ip, dst=dest_vm2.vm_ip, sport=unicode(8000), dport=unicode(9000)) stream3 = Stream(protocol="ip", proto="udp", src=self.vm1_fixture.vm_ip, dst=dest_vm3.vm_ip, sport=unicode(8000), dport=unicode(9000)) self.stream_list = [stream1, stream2, stream3] dst_vm_list = [self.vm2_fixture] self.sender, self.receiver = self.start_traffic( self.vm1_fixture, dst_vm_list, self.stream_list, self.vm1_fixture.vm_ip, self.vm2_fixture.vm_ip) self.logger.info('Sending traffic for 10 seconds') time.sleep(10) self.verify_flow_records(self.vm1_fixture, self.vm1_fixture.vm_ip, self.vm2_fixture.vm_ip) self.stop_traffic(self.sender, self.receiver, dst_vm_list, self.stream_list) return True
def start(self, sender_vm, receiver_vm, proto, sport, dport, pkt_count=None, fip=None, sender_vn_fqname=None, receiver_vn_fqname=None, af=None, interval=0): self.sender_vm = sender_vm self.receiver_vm = receiver_vm self.proto = proto self.sport = sport self.dport = dport self.inputs = sender_vm.inputs self.logger = self.inputs.logger self.pkt_count = pkt_count self.src_ip = sender_vm.get_vm_ips(vn_fq_name=sender_vn_fqname, af=af)[0] recv_ip = receiver_vm.get_vm_ips(vn_fq_name=receiver_vn_fqname, af=af)[0] self.dst_ip = self.recv_ip = recv_ip if fip: self.dst_ip = fip self.interval = interval stream = Stream(sport=self.sport, dport=self.dport, proto=self.proto, src=self.src_ip, dst=self.dst_ip, inter=self.interval) profile_kwargs = {'stream': stream} if fip: profile_kwargs.update({'listener': self.recv_ip}) if self.pkt_count: profile_kwargs.update({'count': self.pkt_count}) profile = StandardProfile(**profile_kwargs) else: profile = ContinuousProfile(**profile_kwargs) # Set VM credentials send_node = Host( self.sender_vm.vm_node_ip, self.sender_vm.inputs.host_data[ self.sender_vm.vm_node_ip]['username'], self.sender_vm.inputs.host_data[ self.sender_vm.vm_node_ip]['password']) recv_node = Host( self.receiver_vm.vm_node_ip, self.sender_vm.inputs.host_data[ self.receiver_vm.vm_node_ip]['username'], self.sender_vm.inputs.host_data[ self.receiver_vm.vm_node_ip]['password']) send_host = Host(self.sender_vm.local_ip, self.sender_vm.vm_username, self.sender_vm.vm_password) recv_host = Host(self.receiver_vm.local_ip, self.receiver_vm.vm_username, self.receiver_vm.vm_password) # Create send, receive helpers random = get_random_name() send_name = 'send' + self.proto + '_' + random recv_name = 'recv' + self.proto + '_' + random sender = Sender(send_name, profile, send_node, send_host, self.logger) receiver = Receiver(recv_name, profile, recv_node, recv_host, self.logger) # start traffic receiver.start() sender.start() self.sender = sender self.receiver = receiver return True
def verify_traffic(self, sender_vm, receiver_vm, proto, sport, dport, count=None, fip=None): # Create stream and profile if fip: stream = Stream(protocol="ip", sport=sport, dport=dport, proto=proto, src=sender_vm.vm_ip, dst=fip) else: stream = Stream(protocol="ip", sport=sport, dport=dport, proto=proto, src=sender_vm.vm_ip, dst=receiver_vm.vm_ip) profile_kwargs = {'stream': stream} if fip: profile_kwargs.update({'listener': receiver_vm.vm_ip}) if count: profile_kwargs.update({'count': count}) profile = StandardProfile(**profile_kwargs) else: profile = ContinuousProfile(**profile_kwargs) # Set VM credentials send_node = Host( sender_vm.vm_node_ip, self.inputs.host_data[sender_vm.vm_node_ip]['username'], self.inputs.host_data[sender_vm.vm_node_ip]['password']) recv_node = Host( receiver_vm.vm_node_ip, self.inputs.host_data[receiver_vm.vm_node_ip]['username'], self.inputs.host_data[receiver_vm.vm_node_ip]['password']) send_host = Host(sender_vm.local_ip, sender_vm.vm_username, sender_vm.vm_password) recv_host = Host(receiver_vm.local_ip, receiver_vm.vm_username, receiver_vm.vm_password) # Create send, receive helpers sender = Sender("send%s" % proto, profile, send_node, send_host, self.inputs.logger) receiver = Receiver("recv%s" % proto, profile, recv_node, recv_host, self.inputs.logger) # start traffic receiver.start() sender.start() sleep(5) # stop traffic sender.stop() receiver.stop() self.logger.debug("Sent: %s; Received: %s", sender.sent, receiver.recv) return (sender.sent, receiver.recv)
def test_verify_flow_tables(self): ''' Description: Test to validate flow tables 1.Creat 2 vn and 1 vm in each vn 2.Create policy between vns 3.send 100 udp packets from vn1 to vn2 4.Verify in vrouter uve that active flow matches with the agent introspect - fails otherwise 5.Query flowrecord table for the flow and verify packet count mtches 100 - fails otherwise 6.Query flow series table or the flow and verify packet count mtches 100 - fails otherwise Maintainer: [email protected] ''' vn1_name = self.res.vn1_name vn1_fq_name = '%s:%s:%s' % ( self.inputs.project_fq_name[0], self.inputs.project_fq_name[1], self.res.vn1_name) vn1_subnets = self.res.vn1_fixture.get_cidrs(af='v4') vn2_name = self.res.vn2_name vn2_fq_name = '%s:%s:%s' % ( self.inputs.project_fq_name[0], self.inputs.project_fq_name[1], self.res.vn2_name) vn2_subnets = self.res.vn2_fixture.get_cidrs(af='v4') policy1_name = 'policy1' policy2_name = 'policy2' result = True rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'udp', 'source_network': vn1_name, 'dest_network': vn2_name, }, ] rev_rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'udp', 'source_network': vn2_name, 'dest_network': vn1_name, }, ] policy1_fixture = self.useFixture( PolicyFixture( policy_name=policy1_name, rules_list=rules, inputs=self.inputs, connections=self.connections)) policy2_fixture = self.useFixture( PolicyFixture( policy_name=policy2_name, rules_list=rev_rules, inputs=self.inputs, connections=self.connections)) vn1_fixture = self.res.vn1_fixture vn1_fixture.bind_policies( [policy1_fixture.policy_fq_name], vn1_fixture.vn_id) self.addCleanup( vn1_fixture.unbind_policies, vn1_fixture.vn_id, [ policy1_fixture.policy_fq_name]) assert vn1_fixture.verify_on_setup() vn2_fixture = self.res.vn2_fixture vn2_fixture.bind_policies( [policy2_fixture.policy_fq_name], vn2_fixture.vn_id) assert vn2_fixture.verify_on_setup() self.addCleanup( vn2_fixture.unbind_policies, vn2_fixture.vn_id, [ policy2_fixture.policy_fq_name]) # self.res.verify_common_objects() # start_time=self.analytics_obj.getstarttime(self.tx_vm_node_ip) # installing traffic package in vm self.res.vn1_vm1_fixture.verify_on_setup() self.res.vn2_vm2_fixture.verify_on_setup() self.res.fvn_vm1_fixture.verify_on_setup() self.res.vn1_vm1_fixture.install_pkg("Traffic") self.res.vn2_vm2_fixture.install_pkg("Traffic") self.res.fvn_vm1_fixture.install_pkg("Traffic") self.tx_vm_node_ip = self.res.vn1_vm1_fixture.vm_node_ip self.rx_vm_node_ip = self.res.vn2_vm2_fixture.vm_node_ip self.tx_local_host = Host( self.tx_vm_node_ip, self.inputs.host_data[ self.tx_vm_node_ip]['username'], self.inputs.host_data[ self.tx_vm_node_ip]['password']) self.rx_local_host = Host( self.rx_vm_node_ip, self.inputs.host_data[ self.rx_vm_node_ip]['username'], self.inputs.host_data[ self.rx_vm_node_ip]['password']) self.send_host = Host(self.res.vn1_vm1_fixture.local_ip, self.res.vn1_vm1_fixture.vm_username, self.res.vn1_vm1_fixture.vm_password) self.recv_host = Host(self.res.vn2_vm2_fixture.local_ip, self.res.vn2_vm2_fixture.vm_username, self.res.vn2_vm2_fixture.vm_password) pkts_before_traffic = self.analytics_obj.get_inter_vn_stats( self.inputs.collector_ips[0], src_vn=vn1_fq_name, other_vn=vn2_fq_name, direction='in') if not pkts_before_traffic: pkts_before_traffic = 0 self.res.vn1_vm1_fixture.wait_till_vm_is_up() self.res.vn1_vm2_fixture.wait_till_vm_is_up() # Create traffic stream self.logger.info("Creating streams...") stream = Stream( protocol="ip", proto="udp", src=self.res.vn1_vm1_fixture.vm_ip, dst=self.res.vn2_vm2_fixture.vm_ip, dport=9000) profile = StandardProfile( stream=stream, size=100, count=10, listener=self.res.vn2_vm2_fixture.vm_ip) sender = Sender( "sendudp", profile, self.tx_local_host, self.send_host, self.inputs.logger) receiver = Receiver( "recvudp", profile, self.rx_local_host, self.recv_host, self.inputs.logger) start_time = self.analytics_obj.getstarttime(self.tx_vm_node_ip) self.logger.info("start time= %s" % (start_time)) receiver.start() sender.start() time.sleep(10) # Poll to make usre traffic flows, optional # sender.poll() # receiver.poll() sender.stop() receiver.stop() print sender.sent, receiver.recv for vn in [self.res.vn1_fixture.vn_fq_name,\ self.res.vn2_fixture.vn_fq_name]: #ACL count if not (int(self.analytics_obj.get_acl\ (self.inputs.collector_ips[0],vn)) > 0): self.logger.error("Acl counts not received from Agent uve \ in %s vn uve"%(vn)) result = result and False if not (int(self.analytics_obj.get_acl\ (self.inputs.collector_ips[0], vn, tier = 'Config')) > 0): self.logger.error("Acl counts not received from Config uve \ in %s vn uve"%(vn)) result = result and False #Bandwidth usage if not (int(self.analytics_obj.get_bandwidth_usage\ (self.inputs.collector_ips[0], vn, direction = 'out')) > 0): self.logger.error("Bandwidth not shown \ in %s vn uve"%(vn)) result = result and False if not (int(self.analytics_obj.get_bandwidth_usage\ (self.inputs.collector_ips[0], vn, direction = 'in')) > 0): self.logger.error("Bandwidth not shown \ in %s vn uve"%(vn)) result = result and False #Flow count if not (int(self.analytics_obj.get_flow\ (self.inputs.collector_ips[0], vn, direction = 'egress')) > 0): self.logger.error("egress flow not shown \ in %s vn uve"%(vn)) result = result and False if not (int(self.analytics_obj.get_flow\ (self.inputs.collector_ips[0], vn, direction = 'ingress')) > 0): self.logger.error("ingress flow not shown \ in %s vn uve"%(vn)) result = result and False #VN stats vns = [self.res.vn1_fixture.vn_fq_name,\ self.res.vn2_fixture.vn_fq_name] vns.remove(vn) other_vn = vns[0] if not (self.analytics_obj.get_vn_stats\ (self.inputs.collector_ips[0], vn, other_vn)): self.logger.error("vn_stats not shown \ in %s vn uve"%(vn)) result = result and False assert "sender.sent == receiver.recv", "UDP traffic to ip:%s failed" % self.res.vn2_vm2_fixture.vm_ip # Verifying the vrouter uve for the active flow vm_node_ip = self.res.vn1_vm1_fixture.inputs.host_data[ self.res.vn1_vm1_fixture.orch.get_host_of_vm( self.res.vn1_vm1_fixture.vm_obj)]['host_ip'] vm_host = self.res.vn1_vm1_fixture.inputs.host_data[vm_node_ip]['name'] self.logger.info( "Waiting for the %s vrouter uve to be updated with active flows" % (vm_host)) time.sleep(60) self.flow_record = self.analytics_obj.get_flows_vrouter_uve( vrouter=vm_host) self.logger.info( "Active flow in vrouter uve = %s" % (self.flow_record)) if (self.flow_record > 0): self.logger.info("Flow records updated") result = result and True else: self.logger.warn("Flow records NOT updated") result = result and False # assert ( self.flow_record > 0) # self.logger.info("Waiting for inter-vn stats to be updated...") # time.sleep(60) pkts_after_traffic = self.analytics_obj.get_inter_vn_stats( self.inputs.collector_ips[0], src_vn=vn1_fq_name, other_vn=vn2_fq_name, direction='in') if not pkts_after_traffic: pkts_after_traffic = 0 self.logger.info("Verifying that the inter-vn stats updated") self.logger.info( "Inter vn stats before traffic %s" % (pkts_before_traffic)) self.logger.info( "Inter vn stats after traffic %s" % (pkts_after_traffic)) if ((pkts_after_traffic - pkts_before_traffic) >= 10): self.logger.info("Inter vn stats updated") result = result and True else: self.logger.warn("Inter vn stats NOT updated") result = result and False self.logger.info("Waiting for flow records to be expired...") time.sleep(224) self.flow_record = self.analytics_obj.get_flows_vrouter_uve( vrouter=vm_host) # if ( self.flow_record > 0): # self.logger.info("Flow records updated") # result = result and True # else: # self.logger.warn("Flow records NOT updated") # result = result and False self.logger.debug( "Active flow in vrouter uve = %s" % (self.flow_record)) # assert ( self.flow_record == 0) # Verifying flow series table src_vn = 'default-domain' + ':' + \ self.inputs.project_name + ':' + self.res.vn1_name dst_vn = 'default-domain' + ':' + \ self.inputs.project_name + ':' + self.res.vn2_name # creating query: '(sourcevn=default-domain:admin:vn1) AND # (destvn=default-domain:admin:vn2)' query = '(' + 'sourcevn=' + src_vn + ') AND (destvn=' + dst_vn + ')' for ip in self.inputs.collector_ips: self.logger.info( "Verifying flowRecordTable through opserver %s.." % (ip)) self.res2 = self.analytics_obj.ops_inspect[ip].post_query( 'FlowRecordTable', start_time=start_time, end_time='now', select_fields=[ 'sourcevn', 'sourceip', 'destvn', 'destip', 'setup_time', 'teardown_time', 'agg-packets'], where_clause=query) self.logger.info("Query output: %s" % (self.res2)) assert self.res2 if self.res2: r = self.res2[0] s_time = r['setup_time'] e_time = r['teardown_time'] agg_pkts = r['agg-packets'] assert (agg_pkts == sender.sent) self.logger.info( 'setup_time= %s,teardown_time= %s' % (s_time, e_time)) self.logger.info("Records=\n%s" % (self.res2)) # Quering flow sreies table self.logger.info( "Verifying flowSeriesTable through opserver %s" % (ip)) self.res1 = self.analytics_obj.ops_inspect[ip].post_query( 'FlowSeriesTable', start_time=str(s_time), end_time='now', select_fields=[ 'sourcevn', 'sourceip', 'destvn', 'destip', 'sum(packets)'], where_clause=query) self.logger.info("Query output: %s" % (self.res1)) assert self.res1 if self.res1: r1 = self.res1[0] sum_pkts = r1['sum(packets)'] assert (sum_pkts == sender.sent) self.logger.info("Flow series Records=\n%s" % (self.res1)) assert (sum_pkts == agg_pkts) assert result return True
def test_verify_flow_series_table_query_range(self): ''' Test to validate flow series table for query range ''' # installing traffic package in vm self.res.vn1_vm1_fixture.install_pkg("Traffic") self.res.vn1_vm2_fixture.install_pkg("Traffic") self.tx_vm_node_ip = self.res.vn1_vm1_fixture.vm_node_ip self.rx_vm_node_ip = self.res.vn1_vm2_fixture.vm_node_ip self.tx_local_host = Host( self.tx_vm_node_ip, self.inputs.host_data[ self.tx_vm_node_ip]['username'], self.inputs.host_data[ self.tx_vm_node_ip]['password']) self.rx_local_host = Host( self.rx_vm_node_ip, self.inputs.host_data[ self.rx_vm_node_ip]['username'], self.inputs.host_data[ self.rx_vm_node_ip]['password']) self.send_host = Host(self.res.vn1_vm1_fixture.local_ip, self.res.vn1_vm1_fixture.vm_username, self.res.vn1_vm1_fixture.vm_password) self.recv_host = Host(self.res.vn1_vm2_fixture.local_ip, self.res.vn1_vm2_fixture.vm_username, self.res.vn1_vm2_fixture.vm_password) # Create traffic stream start_time = self.analytics_obj.getstarttime(self.tx_vm_node_ip) self.logger.info("start time= %s" % (start_time)) self.logger.info("Creating streams...") dport = 11000 stream = Stream( protocol="ip", proto="udp", src=self.res.vn1_vm1_fixture.vm_ip, dst=self.res.vn1_vm2_fixture.vm_ip, dport=dport) startport = 10000 profile = ContinuousSportRange( stream=stream, listener=self.res.vn1_vm2_fixture.vm_ip, startport=10000, endport=dport, pps=100) sender = Sender( 'sname', profile, self.tx_local_host, self.send_host, self.inputs.logger) receiver = Receiver( 'rname', profile, self.rx_local_host, self.recv_host, self.inputs.logger) receiver.start() sender.start() time.sleep(30) sender.stop() receiver.stop() print sender.sent, receiver.recv time.sleep(1) vm_node_ip = self.res.vn1_vm1_fixture.inputs.host_data[ self.res. vn1_vm1_fixture.orch.get_host_of_vm( self.res.vn1_vm1_fixture.vm_obj)]['host_ip'] vm_host = self.res.vn1_vm1_fixture.inputs.host_data[vm_node_ip]['name'] time.sleep(30) # Verifying flow series table src_vn = 'default-domain' + ':' + \ self.inputs.project_name + ':' + self.res.vn1_name dst_vn = 'default-domain' + ':' + \ self.inputs.project_name + ':' + self.res.vn1_name # creating query: '(sourcevn=default-domain:admin:vn1) AND # (destvn=default-domain:admin:vn2)' query = '(sourcevn=%s) AND (destvn=%s) AND protocol= 17 AND (sport = 10500 < 11000)' % ( src_vn, dst_vn) for ip in self.inputs.collector_ips: self.logger.info('setup_time= %s' % (start_time)) # Quering flow sreies table self.logger.info( "Verifying flowSeriesTable through opserver %s" % (ip)) self.res1 = self.analytics_obj.ops_inspect[ip].post_query( 'FlowSeriesTable', start_time=start_time, end_time='now', select_fields=[ 'sourcevn', 'sourceip', 'destvn', 'destip', 'sum(packets)', 'sport', 'dport', 'T=1'], where_clause=query) assert self.res1 for elem in self.res1: if ((elem['sport'] < 10500) or (elem['sport'] > 11000)): self.logger.warn( "Out of range element (range:sport > 15500 and sport < 16000):%s" % (elem)) self.logger.warn("Test Failed") result = False assert result return True
def startTraffic( self, name='stream', num_streams=1, start_port=9100, tx_vm_fixture=None, rx_vm_fixture=None, stream_proto='udp', vm_fip_info=None, packet_size=100, cfg_profile='ContinuousProfile', start_sport=8000, total_single_instance_streams=20, chksum=False, pps=100, fip=None, tx_vn_fixture=None, rx_vn_fixture=None, af=None): ''' Start traffic based on inputs given.. Return {'status': True, 'msg': None} if traffic started successfully..else return {'status': False, 'msg': err_msg}.. Details on inputs: name : Stream identifier; num_streams : number of separate sendpkts instance streams [will take more memory] start_port : Destination start port if num_streams is used tx_vm_fixture & rx_vm_fixture : Needed for vm_ip and vm_mdata_ip [to access vm from compute] stream_proto : TCP, UDP or ICMP; packet_size : if custom size if needed start_sport : if ContinuousSportRange is used, only supports UDP, starting number for source port total_single_instance_streams : if ContinuousSportRange is used, specify number of streams pps :Number of packets to launch per sec ContinuousSportRange launches n streams @defined pps, with one instance of sendpkts.. ''' self.logger.info("startTraffic data: name- %s, stream_proto-%s, packet_size-%s, total_single_instance_streams-%s, chksum-%s, pps-%s" % (name, stream_proto, packet_size, total_single_instance_streams, chksum, pps)) status = True msg = None self.packet_size = packet_size self.chksum = chksum self.start_port = start_port self.start_sport = start_sport self.endport = start_sport + total_single_instance_streams self.total_single_instance_streams = total_single_instance_streams self.tx_vm_fixture = tx_vm_fixture self.rx_vm_fixture = rx_vm_fixture tx_vn_fq_name = tx_vn_fixture.get_vn_fq_name() if tx_vn_fixture else None rx_vn_fq_name = rx_vn_fixture.get_vn_fq_name() if rx_vn_fixture else None af = af if af is not None else self.inputs.get_af() self.stream_proto = stream_proto self.vm_fip_info = vm_fip_info self.traffic_fip = False if self.vm_fip_info == None: self.traffic_fip = False else: self.traffic_fip = True if not self.traffic_fip: self.tx_vm_node_ip = self.tx_vm_fixture.vm_node_ip self.rx_vm_node_ip = self.rx_vm_fixture.vm_node_ip self.tx_local_host = Host( self.tx_vm_node_ip, self.inputs.host_data[self.tx_vm_node_ip]['username'], self.inputs.host_data[self.tx_vm_node_ip]['password']) self.rx_local_host = Host( self.rx_vm_node_ip, self.inputs.host_data[self.rx_vm_node_ip]['username'], self.inputs.host_data[self.rx_vm_node_ip]['password']) self.send_host = Host(self.tx_vm_fixture.local_ip, self.tx_vm_fixture.vm_username, self.tx_vm_fixture.vm_password) self.recv_host = Host(self.rx_vm_fixture.local_ip, self.rx_vm_fixture.vm_username, self.rx_vm_fixture.vm_password) else: self.tx_vm_node_ip = None self.rx_vm_node_ip = None self.tx_local_host = Host( self.inputs.cfgm_ip, self.inputs.host_data[self.tx_vm_node_ip]['username'], self.inputs.host_data[self.tx_vm_node_ip]['password']) self.rx_local_host = Host( self.inputs.cfgm_ip, self.inputs.host_data[self.rx_vm_node_ip]['username'], self.inputs.host_data[self.rx_vm_node_ip]['password']) self.send_host = Host(self.vm_fip_info[self.tx_vm_fixture.vm_name]) self.recv_host = Host(self.vm_fip_info[self.rx_vm_fixture.vm_name]) self.sender = list() self.receiver = list() self.num_streams = 0 if fip is None: self.dst_ips = list(); self.src_ips = list() if af == 'dual' or af == 'v4': self.src_ips.extend(self.tx_vm_fixture.get_vm_ips( vn_fq_name=tx_vn_fq_name, af='v4')) self.dst_ips.extend(self.rx_vm_fixture.get_vm_ips( vn_fq_name=rx_vn_fq_name, af='v4')) if af == 'dual' or af == 'v6': self.src_ips.extend(self.tx_vm_fixture.get_vm_ips( vn_fq_name=tx_vn_fq_name, af='v6')) self.dst_ips.extend(self.rx_vm_fixture.get_vm_ips( vn_fq_name=rx_vn_fq_name, af='v6')) else: self.dst_ips = [fip] self.src_ips = [self.tx_vm_fixture.vm_ip] if len(self.dst_ips) > len(self.src_ips): raise Exception('No of destination ips cant be greater than' ' source ips, for multi stream case') for index in range(len(self.dst_ips)): name = name + '_dst' + str(index) + '_' for i in range(num_streams): self.name = name + self.stream_proto + str(i) self.dport = start_port + i m = "Send protocol %s traffic to port %s" % ( self.stream_proto, self.dport) if self.stream_proto == 'icmp': m = "Send protocol %s traffic" % self.stream_proto self.logger.info(m) stream = Stream(proto=self.stream_proto, src=self.src_ips[index], dst=self.dst_ips[index], dport=self.dport) if fip: listener = self.rx_vm_fixture.vm_ip else: listener = self.dst_ips[index] # stream profile... if cfg_profile == 'ContinuousSportRange': profile = ContinuousSportRange(stream=stream, startport=self.start_sport, endport=self.endport, listener=listener, size=self.packet_size, chksum=self.chksum, pps=pps) elif cfg_profile == 'ContinuousProfile': profile = ContinuousProfile(stream=stream, listener=listener, size=self.packet_size, chksum=self.chksum) # sender profile... sender = Sender(self.name, profile, self.tx_local_host, self.send_host, self.inputs.logger) receiver = Receiver(self.name, profile, self.rx_local_host, self.recv_host, self.inputs.logger) self.logger.info("tx vm - node %s, mdata_ip %s, vm_ip %s" %( self.tx_local_host.ip, self.send_host.ip, self.src_ips[index])) self.logger.info("rx vm - node %s, mdata_ip %s, vm_ip %s" %( self.rx_local_host.ip, self.recv_host.ip, self.dst_ips[index])) receiver.start() self.logger.info("Starting %s traffic from %s to %s" %( self.stream_proto, self.src_ips[index], self.dst_ips[index])) sender.start() retries = 10 j = 0 sender.sent = None while j < retries and sender.sent == None: # wait before checking for stats as it takes time for file # update with stats time.sleep(5) sender.poll() # end while if sender.sent == None: msg = "send %s traffic failure from %s " % ( self.stream_proto, self.src_ips[index]) self.logger.info( "traffic tx stats not available !!, details: %s" % msg) else: self.logger.info( "traffic running good, sent %s pkts so far.." % sender.sent) self.sender.append(sender) self.receiver.append(receiver) self.num_streams += 1 if msg != None: status = False return {'status': status, 'msg': msg}
def test_agent_crash_dns_malformed_received(self): '''Verify that Agent do not crash on sending a malformed DNS packet. This Test case specifically test following Bug Bug Id 1566067 : "Agent crash at BindUtil::DnsClass" Steps: 1. Create a VN with IPAM having Virtual DNS configured. 2. Create a VM and send a DNS query from VM to DNS server. DNS server should have the Qclass field as any value other than "01" 3. Verify that no crash happens when this malformed DNS packet reaches the server Pass criteria: Vrouter agent should not crash on receiving a malformed DNS packet Maintainer: [email protected]''' vm_list = ['vm1', 'vm2'] vn_name = 'vn1' vn_nets = {'vn1' : '10.10.10.0/24'} dns_server_name = 'vdns1' domain_name = 'juniper.net' ttl = 100 ipam_name = 'ipam1' dns_data = VirtualDnsType( domain_name=domain_name, dynamic_records_from_client=True, default_ttl_seconds=ttl, record_order='random', reverse_resolution=True) vdns_fixt1 = self.useFixture(VdnsFixture(self.inputs, self.connections, vdns_name=dns_server_name, dns_data=dns_data)) result, msg = vdns_fixt1.verify_on_setup() self.assertTrue(result, msg) dns_server = IpamDnsAddressType( virtual_dns_server_name=vdns_fixt1.vdns_fq_name) ipam_mgmt_obj = IpamType( ipam_dns_method='virtual-dns-server', ipam_dns_server=dns_server) # Associate IPAM with VDNS server Object ipam_fixt1 = self.useFixture(IPAMFixture(ipam_name, vdns_obj=vdns_fixt1.obj, connections=self.connections, ipamtype=ipam_mgmt_obj)) # Launch VM with VN Created above. vn_fixt = self.useFixture(VNFixture(self.connections, self.inputs, vn_name=vn_name, subnets=[vn_nets['vn1']], ipam_fq_name=ipam_fixt1.fq_name, option='contrail')) vm_fixture1 = self.useFixture(VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixt.obj, vm_name=vm_list[0], image_name = "ubuntu-traffic")) assert vm_fixture1.verify_vm_launched() assert vm_fixture1.verify_on_setup() assert vm_fixture1.wait_till_vm_is_up() # DNS payload with 1 query and qclass as "04" instead of "01" filters = '\'(src host %s and dst host %s and port 1234)\'' \ % (vm_fixture1.vm_ip,vn_fixt.get_dns_ip(ipam_fq_name = ipam_fixt1.fq_name)) session, pcap = start_tcpdump_for_vm_intf(self, vm_fixture1, vn_fixt.vn_fq_name, filters = filters) dnsPayload = '\x12\x34\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x04' streamObj = Stream(protocol="ip", sport=1234, dport=53, proto='udp', src=vm_fixture1.vm_ip, dst=vn_fixt.get_dns_ip(ipam_fq_name =ipam_fixt1.fq_name)) profile_kwargs = {'stream': streamObj, 'count' : 10, 'payload': dnsPayload} profileObj = StandardProfile(**profile_kwargs) tx_vm_node_ip = vm_fixture1.vm_node_ip send_node = Host( tx_vm_node_ip, self.inputs.host_data[tx_vm_node_ip]['username'], self.inputs.host_data[tx_vm_node_ip]['password']) send_host = Host(vm_fixture1.local_ip, vm_fixture1.vm_username, vm_fixture1.vm_password) sender = Sender("senddns", profileObj, send_node, send_host, self.inputs.logger) sender.start() sleep(1) sender.poll() if not sender.sent: self.logger.error("Failed to Transmit packet") assert False, "Failed to Transmit packet" sender.stop() sleep(2) stop_tcpdump_for_vm_intf(self, session, pcap) sleep(2) # grep in pcap file with source port (1234) assert verify_tcpdump_count(self, session, pcap, grep_string="1234", exp_count=10)
def ha_start(self): ''' ha_start will spawn VM's and starts traffic from VM - VM , VM - floating IP. ''' self.vn1_name = 'vn1000' self.vn1_subnets = ['20.1.1.0/24'] self.vn2_name = 'vn2000' self.vn2_subnets = ['50.1.1.0/24'] self.fip_pool_name = self.inputs.fip_pool_name self.fvn_name = 'public-vn-200' self.fip_subnets = [self.inputs.fip_pool] self.vmlist = [] self.vm_fixture = [] self.vm_num = 2 self.jdaf_ip = '6.6.6.1' self.public_ip = '8.8.8.8' self.mx_rt = self.inputs.mx_rt self.secgrp_name = 'default' self.sport = 39100 self.dport = 39200 self.proto_list = ['tcp', 'icmp'] self.fip = "" self.count = "" self.sender = {} self.sender_fip = {} self.receiver = {} self.send_node = {} self.send_fip_node = {} self.recv_node = {} self.send_fip_host = {} self.recv_host = {} self.send_host = {} self.host_list = self.connections.nova_h.get_hosts() for i in range(0, self.vm_num): val = random.randint(1, 100000) self.vmlist.append("vm-test" + str(val)) # ping gateway from VM's self.vn1_fixture = self.useFixture( VNFixture(project_name=self.inputs.project_name, connections=self.connections, vn_name=self.vn1_name, inputs=self.inputs, subnets=self.vn1_subnets, router_asn=self.inputs.router_asn, rt_number=self.mx_rt)) self.vn2_fixture = self.useFixture( VNFixture(project_name=self.inputs.project_name, connections=self.connections, vn_name=self.vn2_name, inputs=self.inputs, subnets=self.vn2_subnets, router_asn=self.inputs.router_asn, enable_dhcp=False, disable_gateway=True)) # self.fvn_fixture= self.useFixture(VNFixture(project_name= self.inputs.project_name, connections= self.connections,vn_name=self.fvn_name, inputs= self.inputs, subnets= self.fip_subnets,router_asn=self.inputs.router_asn, rt_number=self.mx_rt)) # self.fip_fixture = self.useFixture(FloatingIPFixture( project_name=self.inputs.project_name, inputs=self.inputs, connections=self.connections, pool_name=self.fip_pool_name, vn_id=self.fvn_fixture.vn_id)) assert self.vn1_fixture.verify_on_setup() assert self.vn2_fixture.verify_on_setup() # assert self.fvn_fixture.verify_on_setup() # assert self.fip_fixture.verify_on_setup() host_cnt = len(self.host_list) for i in range(0, self.vm_num): node_indx = (i % host_cnt) self.vm_fixture.append( self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_objs=[self.vn1_fixture.obj, self.vn2_fixture.obj], vm_name=self.vmlist[i], flavor='contrail_flavor_large', image_name='ubuntu-traffic', node_name=self.host_list[node_indx]))) # self.vm_fixture.append(self.useFixture(VMFixture(project_name= self.inputs.project_name, connections= self.connections, vn_objs = [ self.vn1_fixture.obj ], vm_name= self.vmlist[i],flavor='contrail_flavor_large',image_name='ubuntu-traffic',node_name=self.host_list[node_indx]))) for i in range(0, self.vm_num): assert self.vm_fixture[i].verify_on_setup() for i in range(0, self.vm_num): out1 = self.nova_h.wait_till_vm_is_up(self.vm_fixture[i].vm_obj) if out1 == False: return { 'result': out1, 'msg': "%s failed to come up" % self.vm_fixture[i].vm_name } else: sleep(10) self.logger.info('Will install Traffic package on %s' % self.vm_fixture[i].vm_name) self.vm_fixture[i].install_pkg("Traffic") ''' self.fip_id = self.fip_fixture.create_and_assoc_fip(self.fvn_fixture.vn_id, self.vm_fixture[0].vm_id) self.addCleanup(self.fip_fixture.disassoc_and_delete_fip, self.fip_id) sleep(10) assert self.fip_fixture.verify_fip(self.fip_id, self.vm_fixture[0], self.fvn_fixture) routing_instance = self.fvn_fixture.ri_name ''' # for i in range(0,self.vm_num): # self.vm_fixture[i].remove_security_group(secgrp='default') # Traffic setup #Set VM credentials for proto in self.proto_list: self.send_node[proto] = [] self.sender[proto] = [] if self.fip == 'True': self.sender_fip[proto] = [] self.receiver[proto] = [] self.send_node[proto] = [] self.recv_node[proto] = [] self.send_host[proto] = [] self.recv_host[proto] = [] j = self.vm_num - 1 for i in range(0, ((self.vm_num / 2))): if self.fip == 'True' and proto == 'icmp': self.stream_fip = Stream(protocol="ip", sport=self.sport, dport=self.dport, proto=proto, src=self.vm_fixture[i].vm_ip, dst=self.public_ip) self.stream = Stream(protocol="ip", sport=self.sport, dport=self.dport, proto=proto, src=self.vm_fixture[i].vm_ip, dst=self.vm_fixture[j].vm_ip) profile_kwargs = {'stream': self.stream} profile = ContinuousProfile(**profile_kwargs) if self.fip == 'True' and proto == 'icmp': profile_fip_kwargs = {'stream': self.stream_fip} profile_fip = ContinuousProfile(**profile_fip_kwargs) self.send_node[proto].append( Host(self.vm_fixture[i].vm_node_ip, self.inputs.username, self.inputs.password)) self.recv_node[proto].append( Host(self.vm_fixture[j].vm_node_ip, self.inputs.username, self.inputs.password)) self.send_host[proto].append( Host(self.vm_fixture[i].local_ip, self.vm_fixture[i].vm_username, self.vm_fixture[i].vm_password)) self.recv_host[proto].append( Host(self.vm_fixture[j].local_ip, self.vm_fixture[j].vm_username, self.vm_fixture[j].vm_password)) # Create send, receive helpers self.sender[proto].append( Sender("send%s" % proto, profile, self.send_node[proto][i], self.send_host[proto][i], self.inputs.logger)) if self.fip == 'True' and proto == 'icmp': self.sender_fip[proto].append( Sender("sendfip%s" % proto, profile_fip, self.send_node[proto][i], self.send_host[proto][i], self.inputs.logger)) self.receiver[proto].append( Receiver("recv%s" % proto, profile, self.recv_node[proto][i], self.recv_host[proto][i], self.inputs.logger)) # start traffic self.receiver[proto][i].start() self.sender[proto][i].start() if self.fip == 'True' and proto == 'icmp': self.sender_fip[proto][i].start() sleep(10) j = j - 1 return True
def test_verify_flow_series_table(self): ''' Test to validate flow series table ''' vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_fixture.get_cidrs(af='v4') vn2_name = self.res.vn2_name vn2_subnets = self.res.vn2_fixture.get_cidrs(af='v4') policy1_name = 'policy1' policy2_name = 'policy2' rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'udp', 'source_network': vn1_name, 'dest_network': vn2_name, }, ] rev_rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'udp', 'source_network': vn2_name, 'dest_network': vn1_name, }, ] policy1_fixture = self.useFixture( PolicyFixture( policy_name=policy1_name, rules_list=rules, inputs=self.inputs, connections=self.connections)) policy2_fixture = self.useFixture( PolicyFixture( policy_name=policy2_name, rules_list=rev_rules, inputs=self.inputs, connections=self.connections)) vn1_fixture = self.res.vn1_fixture vn1_fixture.bind_policies( [policy1_fixture.policy_fq_name], vn1_fixture.vn_id) self.addCleanup( vn1_fixture.unbind_policies, vn1_fixture.vn_id, [ policy1_fixture.policy_fq_name]) assert vn1_fixture.verify_on_setup() vn2_fixture = self.res.vn2_fixture vn2_fixture.bind_policies( [policy2_fixture.policy_fq_name], vn2_fixture.vn_id) assert vn2_fixture.verify_on_setup() self.addCleanup( vn2_fixture.unbind_policies, vn2_fixture.vn_id, [ policy2_fixture.policy_fq_name]) # self.res.verify_common_objects() # installing traffic package in vm self.res.vn1_vm1_fixture.install_pkg("Traffic") self.res.vn2_vm2_fixture.install_pkg("Traffic") # self.res.fvn_vm1_fixture.install_pkg("Traffic") self.tx_vm_node_ip = self.res.vn1_vm1_fixture.vm_node_ip self.rx_vm_node_ip = self.res.vn2_vm2_fixture.vm_node_ip self.tx_local_host = Host( self.tx_vm_node_ip, self.inputs.host_data[ self.tx_vm_node_ip]['username'], self.inputs.host_data[ self.tx_vm_node_ip]['password']) self.rx_local_host = Host( self.rx_vm_node_ip, self.inputs.host_data[ self.rx_vm_node_ip]['username'], self.inputs.host_data[ self.rx_vm_node_ip]['password']) self.send_host = Host(self.res.vn1_vm1_fixture.local_ip, self.res.vn1_vm1_fixture.vm_username, self.res.vn1_vm1_fixture.vm_password) self.recv_host = Host(self.res.vn2_vm2_fixture.local_ip, self.res.vn2_vm2_fixture.vm_username, self.res.vn2_vm2_fixture.vm_password) # Create traffic stream start_time = self.analytics_obj.getstarttime(self.tx_vm_node_ip) self.logger.info("start time= %s" % (start_time)) for i in range(10): count = 100 dport = 9000 count = count * (i + 1) dport = dport + i print 'count=%s' % (count) print 'dport=%s' % (dport) self.logger.info("Creating streams...") stream = Stream( protocol="ip", proto="udp", src=self.res.vn1_vm1_fixture.vm_ip, dst=self.res.vn2_vm2_fixture.vm_ip, dport=dport) profile = StandardProfile( stream=stream, size=100, count=count, listener=self.res.vn2_vm2_fixture.vm_ip) sender = Sender( "sendudp", profile, self.tx_local_host, self.send_host, self.inputs.logger) receiver = Receiver( "recvudp", profile, self.rx_local_host, self.recv_host, self.inputs.logger) receiver.start() sender.start() sender.stop() receiver.stop() print sender.sent, receiver.recv time.sleep(1) vm_node_ip = self.res.vn1_vm1_fixture.inputs.host_data[ self.res.vn1_vm1_fixture.orch.get_host_of_vm( self.res.vn1_vm1_fixture.vm_obj)]['host_ip'] vm_host = self.res.vn1_vm1_fixture.inputs.host_data[vm_node_ip]['name'] time.sleep(300) # Verifying flow series table src_vn = 'default-domain' + ':' + \ self.inputs.project_name + ':' + self.res.vn1_name dst_vn = 'default-domain' + ':' + \ self.inputs.project_name + ':' + self.res.vn2_name # creating query: '(sourcevn=default-domain:admin:vn1) AND # (destvn=default-domain:admin:vn2)' query = '(' + 'sourcevn=' + src_vn + ') AND (destvn=' + dst_vn + ')' for ip in self.inputs.collector_ips: self.logger.info('setup_time= %s' % (start_time)) # Quering flow sreies table self.logger.info( "Verifying flowSeriesTable through opserver %s" % (ip)) self.res1 = self.analytics_obj.ops_inspect[ip].post_query( 'FlowSeriesTable', start_time=start_time, end_time='now', select_fields=[ 'sourcevn', 'sourceip', 'destvn', 'destip', 'sum(packets)', 'sport', 'dport', 'T=1'], where_clause=query, sort=2, limit=5, sort_fields=['sum(packets)']) assert self.res1