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 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 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_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 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 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
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