def verify_traffic(self,
sender_vm,
receiver_vm,
proto,
sport,
dport,
count=None,
fip=None):
# Create stream and profile
if fip:
stream = Stream(sport=sport,
dport=dport,
proto=proto,
src=sender_vm.vm_ip,
dst=fip)
else:
stream = Stream(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 start_traffic(self,
src_vm,
dst_vm_list,
stream_list,
src_ip=None,
dst_ip=None):
self.logger.info("-" * 80)
self.logger.info('Starting Traffic from %s to %s' % (src_ip, dst_ip))
self.logger.info("-" * 80)
profile = {}
sender = {}
receiver = {}
tx_vm_node_ip = self.inputs.host_data[self.nova_h.get_nova_host_of_vm(
src_vm.vm_obj)]['host_ip']
tx_local_host = 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(src_vm.local_ip, src_vm.vm_username,
src_vm.vm_password)
rx_vm_node_ip = {}
rx_local_host = {}
recv_host = {}
for dst_vm in dst_vm_list:
rx_vm_node_ip[dst_vm] = self.inputs.host_data[
self.nova_h.get_nova_host_of_vm(dst_vm.vm_obj)]['host_ip']
rx_local_host[dst_vm] = Host(
rx_vm_node_ip[dst_vm],
self.inputs.host_data[rx_vm_node_ip[dst_vm]]['username'],
self.inputs.host_data[rx_vm_node_ip[dst_vm]]['password'])
recv_host[dst_vm] = Host(dst_vm.local_ip, dst_vm.vm_username,
dst_vm.vm_password)
count = 0
for stream in stream_list:
profile[stream] = {}
sender[stream] = {}
receiver[stream] = {}
for dst_vm in dst_vm_list:
count = count + 1
x = datetime.now().microsecond
send_filename = "sendudp_" + str(x) + "_" + "%s" % count
recv_filename = "recvudp_" + str(x) + "_" + "%s" % count
profile[stream][dst_vm] = ContinuousProfile(
stream=stream, listener=dst_vm.vm_ip, chksum=True)
sender[stream][dst_vm] = Sender(send_filename,
profile[stream][dst_vm],
tx_local_host, send_host,
self.inputs.logger)
receiver[stream][dst_vm] = Receiver(recv_filename,
profile[stream][dst_vm],
rx_local_host[dst_vm],
recv_host[dst_vm],
self.inputs.logger)
receiver[stream][dst_vm].start()
sender[stream][dst_vm].start()
return sender, receiver
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 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_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 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 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}