def __init__(self,net_node_ip,netns,src_vm_ip,dst_vm_ip,netns_dict={}):
"""
::pkt_size, if set to JUMBO we will send out 9000
"""
self.net_node = net_node_ip
self.netns = netns
self.src_ep = src_vm_ip
self.dest_ep = dst_vm_ip
if not isinstance(self.src_ep,list):
self.src_ep = [self.src_ep]
if not isinstance(self.dest_ep,list):
self.dest_ep = [self.dest_ep]
self.pkt_cnt = 3
self.vm_user = '******'
if conf.get('image_user'):
self.vm_user = conf['image_user']
self.vm_password = '******'
if conf.get('image_password'):
self.vm_password = conf['image_password']
self.host_prompt = '\$'
self.vm_prompt = '#'
if conf.get('image_prompt'):
self.vm_prompt = conf['image_prompt']
self.netns_dict = netns_dict
def __init__(self,
net_node_ip,
netns,
src_vm_ip,
dst_vm_ip,
netns_dict={}):
"""
::pkt_size, if set to JUMBO we will send out 9000
"""
self.net_node = net_node_ip
self.netns = netns
self.src_ep = src_vm_ip
self.dest_ep = dst_vm_ip
if not isinstance(self.src_ep, list):
self.src_ep = [self.src_ep]
if not isinstance(self.dest_ep, list):
self.dest_ep = [self.dest_ep]
self.pkt_cnt = 3
self.vm_user = '******'
if conf.get('image_user'):
self.vm_user = conf['image_user']
self.vm_password = '******'
if conf.get('image_password'):
self.vm_password = conf['image_password']
self.host_prompt = '\$'
self.vm_prompt = '#'
if conf.get('image_prompt'):
self.vm_prompt = conf['image_prompt']
self.netns_dict = netns_dict
def spawnVM(self, tenant, vmname, net='', port='', availzone=''):
"""
Method for spawning VMs using net-id or port-id
availzone:: pass it as <zone-name>|<hostname>
hostname as it appears in nova hypervisor-list
"""
image = 'ubuntu_multi_nics'
flavor = 'm1.large'
if conf.get('vm_image'):
image = conf['vm_image']
if conf.get('vm_flavor'):
flavor = conf['vm_flavor']
if net:
cmd = 'nova --os-project-name %s boot %s --image %s --flavor %s --nic net-id=%s' % (
tenant, vmname, image, flavor, net)
if port:
cmd = 'nova --os-project-name %s boot %s --image %s --flavor %s --nic port-id=%s' % (
tenant, vmname, image, flavor, port)
if availzone:
cmd = cmd + ' --availability-zone %s' % (availzone)
print(cmd)
if self.runcmd(cmd):
sleep(20)
num_try = 1
while num_try < max_vm_tries:
match = None
try:
vmout = self.runcmd(
'nova --os-project-name %s show %s | grep network' %
(tenant, vmname))
match = re.search("\\b(\d+.\d+.\d+.\d+)\\b.*", vmout, re.I)
if match:
ips = [
ip.strip() for ip in vmout.split('|')[2].split(',')
]
except Exception:
sleep(max_vm_wait)
num_try += 1
continue
sleep(max_vm_wait)
_out = self.runcmd('nova --os-project-name %s interface-list %s | grep ACTIVE'\
%(tenant,vmname))
if _out or num_try == (max_vm_tries - 1):
break
num_try += 1
if _out: #It may happen even after above 5 retries,_out is still NoneType, so check for that
if _out.succeeded:
portMAC = re.search(r'(([0-9a-f]{2}:){5}[0-9a-f]{2})',
_out, re.I).group()
_match = [i.strip(' ') for i in _out.split('|')]
portID = _match[_match.index('ACTIVE') + 1]
return [ips, portID, portMAC]
else:
return []
else:
return []
else:
return []
def spawnVM(self,tenant,vmname,net='',port='',availzone=''):
"""
Method for spawning VMs using net-id or port-id
availzone:: pass it as <zone-name>|<hostname>
hostname as it appears in nova hypervisor-list
"""
image = 'ubuntu_multi_nics'
flavor = 'm1.large'
if conf.get('vm_image'):
image = conf['vm_image']
if conf.get('vm_flavor'):
flavor = conf['vm_flavor']
if net:
cmd = 'nova --os-project-name %s boot %s --image %s --flavor %s --nic net-id=%s' %(tenant,vmname,image,flavor,net)
if port:
cmd = 'nova --os-project-name %s boot %s --image %s --flavor %s --nic port-id=%s' %(tenant,vmname,image,flavor,port)
if availzone:
cmd = cmd+' --availability-zone %s' %(availzone)
print(cmd)
if self.runcmd(cmd):
sleep(20)
num_try = 1
while num_try < max_vm_tries:
match = None
try:
vmout = self.runcmd('nova --os-project-name %s show %s | grep network' %(tenant,vmname))
match = re.search("\\b(\d+.\d+.\d+.\d+)\\b.*",vmout,re.I)
if match:
ips = [ip.strip() for ip in vmout.split('|')[2].split(',')]
except Exception:
sleep(max_vm_wait)
num_try+=1
continue
sleep(max_vm_wait)
_out = self.runcmd('nova --os-project-name %s interface-list %s | grep ACTIVE'\
%(tenant,vmname))
if _out or num_try == (max_vm_tries - 1):
break
num_try+=1
if _out: #It may happen even after above 5 retries,_out is still NoneType, so check for that
if _out.succeeded:
portMAC = re.search(r'(([0-9a-f]{2}:){5}[0-9a-f]{2})',_out,re.I).group()
_match = [i.strip(' ') for i in _out.split('|')]
portID = _match[_match.index('ACTIVE')+1]
return [ips,portID,portMAC]
else:
return []
else:
return []
else:
return []
class super_hdr(object):
# Name of the config file is static
nova_az = conf['nova_az_name']
cntlr_ip = conf['controller_ip']
cntlr_user = conf.get('controller_user') or 'root'
cntlr_passwd = conf.get('controller_password') or 'noir0123'
apic_ip = conf['apic_ip']
apic_passwd = conf['apic_passwd']
num_host = conf['num_comp_nodes']
heat_temp = conf['main_setup_heat_temp']
stack_name = conf['heat_dp_stack_name']
vm_image = conf['vm_image']
sshkeyname = conf['key_name']
network_node = conf['network_node']
apicsystemID = conf['apic_system_id']
pausetodebug = conf['pausetodebug']
plugin = conf['plugin-type']
gbpcfg = gbpCfgCli(cntlr_ip,
cntrlr_username=cntlr_user,
cntrlr_passwd=cntlr_passwd,
rcfile=rcfile)
gbpnova = gbpNova(cntlr_ip)
gbpheat = gbpHeat(cntlr_ip)
def vm_create(self, ptgs, vmlist):
"""
Create VMs
"""
# ptg_id should be a dict with keys as 'data' & 'mgmt'
# vm_list: list of dicts
for vm in vmlist:
for key, val in ptgs.iteritems():
port = self.gbpcfg.gbp_policy_cfg_all(
1,
'target',
'vm_%s' % (key),
policy_target_group='%s' % (val))
if port != 0:
vm[key] = port[1]
else:
raise TestSuiteAbort("Policy Targets creation Failed")
print vm
# removed mgmt_nic
if self.gbpnova.vm_create_cli(vm['name'],
self.vm_image,
vm['data'],
avail_zone=vm['az']) == 0:
return 0
def AddSShContract(self,apicip):
"""
Adds SSH contract between NS and EPG
Needed for SNAT Tests
"""
LOG.info(
"\n ADDING SSH-Filter to Svc_epg created for every dhcp_agent")
if not PLUGIN_TYPE:
if conf.get('apic_passwd'):
aci=gbpApic(apicip, password=conf['apic_passwd'])
else:
aci=gbpApic(apicip)
aci.create_add_filter('admin')
else:
if not CONTAINERIZED_SERVICES:
cmd = "python add_ssh_filter.py create"
else:
cmd = "python /home/add_ssh_filter.py create"
if isinstance (run_remote_cli(cmd,
CNTRLRIP, CTRLR_USER, CTRLR_PSWD,
service='aim'), tuple):
LOG.warning("adding filter to SvcEpg failed in AIM")
return 0
sleep(15) # TODO: SSH/Ping fails possible its taking time PolicyDownload
return 1
def AddSShContract(self, apicip):
"""
Adds SSH contract between NS and EPG
Needed for SNAT Tests
"""
LOG.info(
"\n ADDING SSH-Filter to Svc_epg created for every dhcp_agent")
if not PLUGIN_TYPE:
if conf.get('apic_passwd'):
aci = gbpApic(apicip, password=conf['apic_passwd'])
else:
aci = gbpApic(apicip)
aci.create_add_filter('admin')
else:
if not CONTAINERIZED_SERVICES:
cmd = "python add_ssh_filter.py create"
else:
cmd = "python /home/add_ssh_filter.py create"
if isinstance(
run_remote_cli(cmd,
CNTRLRIP,
CTRLR_USER,
CTRLR_PSWD,
service='aim'), tuple):
LOG.warning("adding filter to SvcEpg failed in AIM")
return 0
sleep(
15) # TODO: SSH/Ping fails possible its taking time PolicyDownload
return 1
def ssh_to_compute_host(self):
self.host_prompt = '\$'
if conf.get('director_deploy') and conf['director_deploy'] == 'True':
pexpect_session = pexpect.spawn('ssh heat-admin@%s' %(self.net_node))
pexpect_session.expect(self.host_prompt) #Expecting passwordless access
else:
pexpect_session = pexpect.spawn('ssh root@%s' %(self.net_node))
pexpect_session.expect(self.host_prompt) #Expecting passwordless access
pexpect_session.sendline('hostname')
pexpect_session.expect(self.host_prompt)
print pexpect_session.before
self.host_sudo(pexpect_session)
return pexpect_session
def gbpExpTraff(net_node_ip, netns, src_vm_ip, dst_vm_ip, netns_dict={}):
if conf.get('no_hping3') and conf['no_hping3'] == 'True':
return gbpExpTraffNetcat(net_node_ip,
netns,
src_vm_ip,
dst_vm_ip,
netns_dict=netns_dict)
else:
return gbpExpTraffHping3(net_node_ip,
netns,
src_vm_ip,
dst_vm_ip,
netns_dict=netns_dict)
def testLaunchVmsForEachPt(self, az2='', same=False):
"""
Launch VMs in two diff avail-zones
az2:: second avail-zone, az1=nova(default)
same:: True, then VMs launched in same avail-zone
"""
az1 = 'nova' #default in openstack
vm_image = 'ubuntu_multi_nics'
vm_flavor = 'm1.medium'
if conf.get('vm_image'):
vm_image = conf['vm_image']
if conf.get('vm_flavor'):
vm_flavor = conf['vm_flavor']
if same:
az2 = az1
LOG.info("\nStep: Launch VMs in same avail-zones\n")
else:
LOG.info("\nStep: Launch VMs in two diff avail-zones\n")
# launch Nova VMs
if gbpnova.vm_create_api(VM1_NAME,
vm_image, [{
'port-id': self.pt1id[1]
}],
flavor_name=conf['vm_flavor'],
avail_zone=az1) == 0:
LOG.error("\n///// VM Create using PTG %s failed /////" %
(PTG1NAME))
return 0
if gbpnova.vm_create_api(VM2_NAME,
vm_image, [{
'port-id': self.pt2id[1]
}],
flavor_name=conf['vm_flavor'],
avail_zone=az2) == 0:
LOG.error("\n///// VM Create using PTG %s failed /////" %
(PTG2NAME))
return 0
return 1
def testLaunchVmsForEachPt(self,az2='',same=False):
"""
Launch VMs in two diff avail-zones
az2:: second avail-zone, az1=nova(default)
same:: True, then VMs launched in same avail-zone
"""
az1 = 'nova' #default in openstack
vm_image = 'ubuntu_multi_nics'
vm_flavor = 'm1.medium'
if conf.get('vm_image'):
vm_image = conf['vm_image']
if conf.get('vm_flavor'):
vm_flavor = conf['vm_flavor']
if same:
az2 = az1
LOG.info("\nStep: Launch VMs in same avail-zones\n")
else:
LOG.info("\nStep: Launch VMs in two diff avail-zones\n")
# launch Nova VMs
if gbpnova.vm_create_api(VM1_NAME,
vm_image,
[{'port-id': self.pt1id[1]}],
flavor_name=conf['vm_flavor'],
avail_zone=az1) == 0:
LOG.error(
"\n///// VM Create using PTG %s failed /////" %(PTG1NAME))
return 0
if gbpnova.vm_create_api(VM2_NAME,
vm_image,
[{'port-id': self.pt2id[1]}],
flavor_name=conf['vm_flavor'],
avail_zone=az2) == 0:
LOG.error(
"\n///// VM Create using PTG %s failed /////" %(PTG2NAME))
return 0
return 1
def ssh_to_compute_host(self):
self.host_prompt = '\$'
if conf.get('director_deploy') and conf['director_deploy'] == 'True':
pexpect_session = pexpect.spawn('ssh heat-admin@%s' %
(self.net_node))
pexpect_session.expect(
self.host_prompt) #Expecting passwordless access
else:
pexpect_session = pexpect.spawn('ssh root@%s' % (self.net_node))
pexpect_session.expect(
self.host_prompt) #Expecting passwordless access
pexpect_session.sendline('hostname')
pexpect_session.expect(self.host_prompt)
print pexpect_session.before
self.host_sudo(pexpect_session)
return pexpect_session
def __init__(self):
"""
Iniatizing the test-cfg variables & classes
"""
self.apicsystemID = conf['apic_system_id']
self.nova_agg = conf['nova_agg_name']
self.nova_az = conf['nova_az_name']
self.comp_node = conf['az_comp_node']
self.network_node = conf['network_node']
self.cntlr_ip = conf['controller_ip']
self.cntlr_user = conf.get('controller_user') or 'root'
self.cntlr_passwd = conf.get('controller_password') or 'noir0123'
self.key_ip = conf.get('keystone_ip') or self.cntlr_ip
self.key_user = conf.get('keystone_user') or 'admin'
self.key_passwd = conf.get('keystone_password') or 'noir0123'
self.apic_ip = conf['apic_ip']
self.leaf1_ip = conf['leaf1_ip']
self.leaf2_ip = conf['leaf2_ip']
self.spine_ip = conf['spine_ip']
self.apic_passwd = conf.get('apic_passwd')
self.heat_temp_test = conf['main_setup_heat_temp']
self.num_hosts = conf['num_comp_nodes']
self.heat_stack_name = conf['heat_dp_stack_name']
self.pausetodebug = conf['pausetodebug']
self.test_parameters = conf['test_parameters']
self.plugin = conf['plugin-type']
self.gbpnova = gbpNova(self.cntlr_ip,cntrlr_uname=self.cntlr_user,cntrlr_passwd=self.cntlr_passwd,
keystone_user=self.key_user,keystone_password=self.key_passwd)
self.gbpheat = gbpHeat(self.cntlr_ip,cntrlr_uname=self.cntlr_user, cntrlr_passwd=self.cntlr_passwd)
if self.plugin: #Incase of MergedPlugin
if self.apic_passwd:
self.gbpaci = gbpApic(self.apic_ip, mode='aim',
password=self.apic_passwd)
else:
self.gbpaci = gbpApic(self.apic_ip, mode='aim')
else:
self.gbpaci = gbpApic(self.apic_ip, password=self.apic_passwd,
apicsystemID=self.apicsystemID)
self.vmlist = ['VM1','VM2','VM3','VM4',
'VM5','VM6','VM7','VM8',
'VM9','VM10','VM11','VM12'
]
#Below L2Ps needed for APIC Verification
self.L2plist = [
'demo_same_ptg_l2p_l3p_bd',
'demo_diff_ptg_same_l2p_l3p_bd',
'demo_diff_ptg_l2p_same_l3p_bd_1',
'demo_diff_ptg_l2p_same_l3p_bd_2',
'demo_srvr_bd', 'demo_clnt_bd'
]
def _get_template_parameters(self):
"""Get parameters values for heat template.
Get the list of parameters supported by the heat template,
and search the testconfig.yaml file for any values that match.
"""
parameter_args = []
if self.heat_temp_test:
import socket
print("hostname is %s" % socket.gethostname())
import os
print "current directory is %s" % os.getcwd()
fd = open(self.heat_temp_test, 'r')
if not fd:
return
template_data = yaml.load(fd)
for parameter in template_data['parameters']:
if conf.get(parameter):
parameter_args.append(' -P ' + parameter + '=' + conf[parameter])
if parameter_args:
return ''.join(parameter_args)
else:
return None
#!/usr/bin/env python
import sys
import logging
import os
import datetime
import pprint
import string
import uuid
from libs.gbp_crud_libs import GBPCrud
from traff_from_extgw import *
from libs.gbp_utils import *
from testcases.config import conf
L3OUT1=conf.get('primary_L3out')
L3OUT1_NET=conf.get('primary_L3out_net')
L3OUT2=conf.get('secondary_L3out')
L3OUT2_NET=conf.get('secondary_L3out_net')
class DNAT_ExtGw_to_VMs(object):
# Initialize logging
# logging.basicConfig(level=logging.INFO)
_log = logging.getLogger(__name__)
_log.setLevel(logging.INFO)
# create a logfile handler
hdlr = logging.FileHandler('/tmp/testsuite_dnat_extgw_to_vms.log')
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
hdlr.setFormatter(formatter)
# Add the handler to the logger
#!/usr/bin/env python
import sys
import logging
import os
import datetime
import pprint
import string
import uuid
from libs.gbp_crud_libs import GBPCrud
from traff_from_extgw import *
from libs.gbp_utils import *
from testcases.config import conf
L3OUT1 = conf.get('primary_L3out')
L3OUT1_NET = conf.get('primary_L3out_net')
L3OUT2 = conf.get('secondary_L3out')
L3OUT2_NET = conf.get('secondary_L3out_net')
class DNAT_ExtGw_to_VMs(object):
# Initialize logging
# logging.basicConfig(level=logging.INFO)
_log = logging.getLogger(__name__)
_log.setLevel(logging.INFO)
# create a logfile handler
hdlr = logging.FileHandler('/tmp/testsuite_dnat_extgw_to_vms.log')
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
hdlr.setFormatter(formatter)
# Add the handler to the logger
#!/usr/bin/python
import sys
import logging
import os
import datetime
import string
import re
from libs.gbp_conf_libs import gbpCfgCli
from libs.gbp_nova_libs import gbpNova
from libs.gbp_fab_traff_libs import gbpFabTraff
from libs.gbp_pexp_traff_libs import gbpExpTraff
from libs.raise_exceptions import *
from testcases.config import conf
CNTRLR_USR = conf.get('controller_user') or 'root'
CNTRLR_PASSWD = conf.get('controller_password') or 'noir0123'
KEY_USER = conf.get('keystone_user') or 'admin'
KEY_PASSWD = conf.get('keystone_password') or 'noir0123'
RCFILE = conf.get('rcfile') or 'overcloudrc'
class NatTraffic(object):
"""
NAT Traffic Base Class
"""
def __init__(self, ostack_cntrlr_ip, vm_list, ntk_node):
self.ntk_node = ntk_node
self.gbpcfg = gbpCfgCli(ostack_cntrlr_ip, cntrlr_username=CNTRLR_USR,
#!/usr/bin/python
import sys
import logging
import os
import datetime
import string
import re
from time import sleep
from libs.gbp_fab_traff_libs import gbpFabTraff
from libs.gbp_pexp_traff_libs import gbpExpTraff
from libs.raise_exceptions import *
from testcases.config import conf
max_traff_attempts = conf.get('traffic_attempts', 10)
def traff_from_extgwrtr(extgwrtr_ip, fipsOftargetVMs, proto='all', jumbo=0):
"""
Traffic from ExternalGW Router to Tenant VMs
"""
traff = gbpFabTraff()
print 'FIPs of Target VMs == %s' % (fipsOftargetVMs)
# List of FIPs ExtGWRtr will ping, ping_fips should be type List
if isinstance(fipsOftargetVMs, dict):
ping_fips = fipsOftargetVMs.values()
if isinstance(fipsOftargetVMs, list):
ping_fips = fipsOftargetVMs
if not isinstance(fipsOftargetVMs, list):
ping_fips = [fipsOftargetVMs]
attemptall = 1
#!/usr/bin/env python
import sys
import logging
import os
import datetime
import yaml
from libs.gbp_conf_libs import gbpCfgCli
from libs.gbp_heat_libs import gbpHeat
from libs.gbp_nova_libs import gbpNova
from libs.raise_exceptions import *
from testcases.config import conf
rcfile = conf.get('rcfile') or 'overcloudrc'
class super_hdr(object):
# Name of the config file is static
nova_az = conf['nova_az_name']
cntlr_ip = conf['controller_ip']
cntlr_user = conf.get('controller_user') or 'root'
cntlr_passwd = conf.get('controller_password') or 'noir0123'
apic_ip = conf['apic_ip']
apic_passwd = conf['apic_passwd']
num_host = conf['num_comp_nodes']
heat_temp = conf['main_setup_heat_temp']
stack_name = conf['heat_dp_stack_name']
vm_image = conf['vm_image']
sshkeyname = conf['key_name']
network_node = conf['network_node']
apicsystemID = conf['apic_system_id']
pausetodebug = conf['pausetodebug']
from traff_from_allvms_to_extgw import NatTraffic
# Initialize logging
LOG = logging.getLogger(__name__)
LOG.setLevel(logging.ERROR)
# create a logfile handler
hdlr = logging.FileHandler('/tmp/test_nat_functionality.log')
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
hdlr.setFormatter(formatter)
# Add the handler to the logger
LOG.addHandler(hdlr)
# CONSTANTS & CONFIG DEFINITION
PLUGIN_TYPE = conf['plugin-type']
CNTRLRIP = conf['controller_ip']
CNTRLR_USR = conf.get('controller_user') or 'root'
CNTRLR_PASSWD = conf.get('controller_password') or 'noir0123'
APICIP = conf['apic_ip']
NTKNODE = conf['network_node']
EXTRTR = conf['ext_rtr']
EXTRTR_IP1 = conf['extrtr_ip1']
EXTRTR_IP2 = conf['extrtr_ip2']
GWIP1_EXTRTR = conf['gwip1_extrtr']
GWIP2_EXTRTR = conf['gwip2_extrtr']
NOVA_AGG = conf['nova_agg_name']
AVAIL_ZONE = conf['nova_az_name']
AZ_COMP_NODE = conf['az_comp_node']
PAUSETODEBG = conf['pausetodebug']
EXTSEG_PRI = conf['primary_L3out']
EXTSEG_PRI_NET = conf.get('primary_L3out_net')
EXTSEG_SEC = conf['secondary_L3out']
#!/usr/bin/python
import sys
import logging
import os
import datetime
import string
import re
from time import sleep
from libs.gbp_fab_traff_libs import gbpFabTraff
from libs.gbp_pexp_traff_libs import gbpExpTraff
from libs.raise_exceptions import *
from testcases.config import conf
max_traff_attempts = conf.get('traffic_attempts', 10)
def traff_from_extgwrtr(extgwrtr_ip, fipsOftargetVMs, proto='all', jumbo=0):
"""
Traffic from ExternalGW Router to Tenant VMs
"""
traff = gbpFabTraff()
print 'FIPs of Target VMs == %s' % (fipsOftargetVMs)
# List of FIPs ExtGWRtr will ping, ping_fips should be type List
if isinstance(fipsOftargetVMs,dict):
ping_fips = fipsOftargetVMs.values()
if isinstance(fipsOftargetVMs,list):
ping_fips = fipsOftargetVMs
if not isinstance(fipsOftargetVMs,list):
ping_fips = [fipsOftargetVMs]
attemptall = 1
if proto == 'all':
def gbpExpTraff(net_node_ip,netns,src_vm_ip,dst_vm_ip,netns_dict={}):
if conf.get('no_hping3') and conf['no_hping3'] == 'True':
return gbpExpTraffNetcat(net_node_ip,netns,src_vm_ip,dst_vm_ip,netns_dict=netns_dict)
else:
return gbpExpTraffHping3(net_node_ip,netns,src_vm_ip,dst_vm_ip,netns_dict=netns_dict)
#!/usr/bin/env python
import sys
import logging
import os
import datetime
import yaml
from libs.gbp_conf_libs import gbpCfgCli
from libs.gbp_heat_libs import gbpHeat
from libs.gbp_nova_libs import gbpNova
from libs.raise_exceptions import *
from testcases.config import conf
rcfile = conf.get('rcfile') or 'overcloudrc'
class super_hdr(object):
# Name of the config file is static
nova_az = conf['nova_az_name']
cntlr_ip = conf['controller_ip']
cntlr_user = conf.get('controller_user') or 'root'
cntlr_passwd = conf.get('controller_password') or 'noir0123'
apic_ip = conf['apic_ip']
apic_passwd = conf['apic_passwd']
num_host = conf['num_comp_nodes']
heat_temp = conf['main_setup_heat_temp']
stack_name = conf['heat_dp_stack_name']
vm_image = conf['vm_image']
sshkeyname = conf['key_name']
network_node = conf['network_node']
apicsystemID = conf['apic_system_id']
from traff_from_allvms_to_extgw import NatTraffic
# Initialize logging
LOG = logging.getLogger(__name__)
LOG.setLevel(logging.ERROR)
# create a logfile handler
hdlr = logging.FileHandler('/tmp/test_nat_functionality.log')
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
hdlr.setFormatter(formatter)
# Add the handler to the logger
LOG.addHandler(hdlr)
# CONSTANTS & CONFIG DEFINITION
PLUGIN_TYPE = conf['plugin-type']
CNTRLRIP = conf['controller_ip']
CNTRLR_USR = conf.get('controller_user') or 'root'
CNTRLR_PASSWD = conf.get('controller_password') or 'noir0123'
APICIP = conf['apic_ip']
NTKNODE = conf['network_node']
EXTRTR = conf['ext_rtr']
EXTRTR_IP1 = conf['extrtr_ip1']
EXTRTR_IP2 = conf['extrtr_ip2']
GWIP1_EXTRTR = conf['gwip1_extrtr']
GWIP2_EXTRTR = conf['gwip2_extrtr']
NOVA_AGG = conf['nova_agg_name']
AVAIL_ZONE = conf['nova_az_name']
AZ_COMP_NODE = conf['az_comp_node']
PAUSETODEBG = conf['pausetodebug']
EXTSEG_PRI = conf['primary_L3out']
EXTSEG_PRI_NET = conf.get('primary_L3out_net')
EXTSEG_SEC = conf['secondary_L3out']
#!/usr/bin/env python
import netaddr
import sys
import re
from time import sleep
from fabric.api import cd, run, env, hide, get, settings
from fabric.context_managers import *
from neutronclient.v2_0 import client as nclient
from testcases.config import conf
from keystoneauth1 import identity
from keystoneauth1 import session
VRF_PREFIX = "--apic:distinguished_names type=dict VRF='"
max_vm_wait = conf.get('vm_wait', 20)
max_vm_tries = conf.get('vm_tries', 10)
rcfile = conf.get('rcfile', 'overcloudrc')
class neutronPy(object):
def __init__(self, controllerIp, username='******', password='******', tenant='admin'):
cred = {}
cred['username'] = username
cred['password'] = password
cred['tenant_name'] = tenant
cred['auth_url'] = "http://%s:5000/v3/" % controllerIp
auth = identity.Password(auth_url=cred['auth_url'],
username=username,
password=password,
project_name=tenant,
project_domain_name='Default',
user_domain_name='Default')
#!/usr/bin/env python
import sys
from fabric.api import cd, run, env, hide, get, settings, local ,put
from fabric.context_managers import *
from testcases.config import conf
from libs.gbp_nova_libs import gbpNova
from libs.gbp_utils import *
KEY_USER = conf.get('keystone_user')
KEY_PASSWORD = conf.get('keystone_password')
CNTRLRIP = conf['controller_ip']
APICIP = conf['apic_ip']
NTKNODE = conf['network_node']
CONTAINERIZED_SERVICES = conf.get('containerized_services')
def main():
setup(CNTRLRIP,APICIP,NTKNODE)
def setup(controller_ip,apic_ip,ntknode,cntlr_user='******',apic_user='******',
apic_pwd = 'noir0123', cntlr_pwd='noir0123'):
env.host_string = controller_ip
env.user = cntlr_user
env.password = cntlr_pwd
#Step-0.5: Make sure GBP client is installed on the controller
cmd = "sudo yum -y install python-gbpclient.noarch"
run(cmd)
#Step-1: Copy the Heat Templates to the Controller
for heat_templt in ['~/noirotest/testcases/heat_temps/heat_dnat_only.yaml',
#!/usr/bin/env python
import netaddr
import sys
import re
from time import sleep
from fabric.api import cd, run, env, hide, get, settings
from fabric.context_managers import *
from neutronclient.v2_0 import client as nclient
from testcases.config import conf
from keystoneauth1 import identity
from keystoneauth1 import session
VRF_PREFIX = "--apic:distinguished_names type=dict VRF='"
max_vm_wait = conf.get('vm_wait', 20)
max_vm_tries = conf.get('vm_tries', 10)
rcfile = conf.get('rcfile', 'overcloudrc')
class neutronPy(object):
def __init__(self,
controllerIp,
username='******',
password='******',
tenant='admin'):
cred = {}
cred['username'] = username
cred['password'] = password
cred['tenant_name'] = tenant
cred['auth_url'] = "http://%s:5000/v3/" % controllerIp
auth = identity.Password(auth_url=cred['auth_url'],
#!/usr/bin/python
from commands import *
import datetime
import logging
import sys
import yaml
from time import sleep
from libs.gbp_aci_libs import GbpApic
from libs.gbp_crud_libs import GBPCrud
from libs.gbp_nova_libs import gbpNova
from testcases.config import conf
KEYSTONE=conf.get('keystone_ip')
Log = logging.getLogger(__name__)
Log.setLevel(logging.INFO)
# create a logfile handler
hdlr = logging.FileHandler('/tmp/gbpcleanup')
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
hdlr.setFormatter(formatter)
# Add the handler to the logger
Log.addHandler(hdlr)
class GbpAllCleanup(object):
def __init__(self,cntlrip,apicip):
self.gbpcrud = GBPCrud(cntlrip)
self.gbpnova = gbpNova(cntlrip)
self.gbpapic = gbpApic(apicip)
def cleanupAll(self):
import itertools
import os
from prettytable import PrettyTable
import re
import subprocess
import sys
#import HTML
from fabric.api import cd,run,env, hide, get, settings,sudo,local
from fabric.contrib import files
from fabric.context_managers import *
from raise_exceptions import *
from time import sleep
from testcases.config import conf
L3OUT1=conf.get('primary_L3out')
L3OUT1_NET=conf.get('primary_L3out_net')
L3OUT2=conf.get('secondary_L3out')
L3OUT2_NET=conf.get('secondary_L3out_net')
CONTAINERIZED_SERVICES=conf.get('containerized_services', [])
RCFILE=conf.get('rcfile', 'overcloudrc')
def run_openstack_cli(cmdList,cntrlrip,
username='******',passwd='noir0123', do_sudo=False):
"""
This function enables the user to
run cli-cmds on openstack env
cmdList: preferably pass the cmd/set of cmds
as a list
"""
env.host_string = cntrlrip
#!/usr/bin/python
import sys
import logging
import os
import datetime
import string
from libs.gbp_conf_libs import gbpCfgCli
from libs.gbp_fab_traff_libs import gbpFabTraff
from libs.gbp_pexp_traff_libs import gbpExpTraff
from libs.raise_exceptions import *
from testsuites_setup_cleanup import super_hdr
from libs.gbp_utils import *
from testcases.config import conf
cntlr_user = conf.get('controller_user') or 'root'
cntlr_passwd = conf.get('controller_password') or 'noir0123'
rcfile = conf.get('rcfile') or 'overcloudrc'
class test_diff_ptg_diff_l2p_diff_l3p(object):
"""
This is a TestCase Class comprising
all Datapath testcases for the Test Header:
diff_ptg_diff_l2p_diff_l3p
Every new testcases should be added as a new method in this class
and call the testcase method inside the 'test_runner' method
"""
# Initialize logging
#logging.basicConfig(level=logging.INFO)
#!/usr/bin/python
import sys
import logging
import os
import datetime
import string
import re
from libs.gbp_conf_libs import gbpCfgCli
from libs.gbp_nova_libs import gbpNova
from libs.gbp_fab_traff_libs import gbpFabTraff
from libs.gbp_pexp_traff_libs import gbpExpTraff
from libs.raise_exceptions import *
from testcases.config import conf
CNTRLR_USR = conf.get('controller_user') or 'root'
CNTRLR_PASSWD = conf.get('controller_password') or 'noir0123'
KEY_USER = conf.get('keystone_user') or 'admin'
KEY_PASSWD = conf.get('keystone_password') or 'noir0123'
RCFILE = conf.get('rcfile') or 'overcloudrc'
class NatTraffic(object):
"""
NAT Traffic Base Class
"""
def __init__(self, ostack_cntrlr_ip, vm_list, ntk_node):
self.ntk_node = ntk_node
self.gbpcfg = gbpCfgCli(ostack_cntrlr_ip,
cntrlr_username=CNTRLR_USR,
import sys
import logging
import os
import datetime
import string
import pprint
from libs.gbp_conf_libs import gbpCfgCli
from libs.gbp_fab_traff_libs import gbpFabTraff
from libs.gbp_pexp_traff_libs import gbpExpTraff
from libs.raise_exceptions import *
from testsuites_setup_cleanup import super_hdr
from libs.gbp_utils import *
from testcases.config import conf
cntlr_user = conf.get('controller_user') or 'root'
cntlr_passwd = conf.get('controller_password') or 'noir0123'
rcfile = conf.get('rcfile') or 'overcloudrc'
class test_diff_ptg_diff_l2p_same_l3p(object):
"""
This is a TestCase Class comprising
all Datapath testcases for the Test Header:
diff_ptg_diff_l2p_same_l3p
Every new testcases should be added as a new method in this class
and call the testcase method inside the 'test_runner' method
"""
# Initialize logging
#logging.basicConfig(level=logging.INFO)
_log = logging.getLogger(__name__)
#!/usr/bin/env python
import sys
from fabric.api import cd, run, env, hide, get, settings, local, put
from fabric.context_managers import *
from testcases.config import conf
from libs.gbp_nova_libs import gbpNova
from libs.gbp_utils import *
KEY_USER = conf.get('keystone_user')
KEY_PASSWORD = conf.get('keystone_password')
CNTRLRIP = conf['controller_ip']
APICIP = conf['apic_ip']
NTKNODE = conf['network_node']
CONTAINERIZED_SERVICES = conf.get('containerized_services')
def main():
setup(CNTRLRIP, APICIP, NTKNODE)
def setup(controller_ip,
apic_ip,
ntknode,
cntlr_user='******',
apic_user='******',
apic_pwd='noir0123',
cntlr_pwd='noir0123'):
env.host_string = controller_ip
env.user = cntlr_user
env.password = cntlr_pwd
import os
import datetime
import yaml
from time import sleep
from libs.gbp_heat_libs import gbpHeat
from libs.gbp_nova_libs import gbpNova
from libs.gbp_aci_libs import gbpApic
from libs.gbp_compute import Compute
from libs.keystone import Keystone
from libs.gbp_utils import *
from testcases.config import conf
APICSYSTEM_ID = conf['apic_system_id']
network_node = conf['network_node']
cntlr_ip = conf['controller_ip']
cntlr_user = conf.get('controller_user') or 'root'
cntlr_passwd = conf.get('controller_password') or 'noir0123'
key_user = conf.get('keystone_user') or 'admin'
key_passwd = conf.get('keystone_password') or 'noir0123'
apic_ip = conf['apic_ip']
leaf1_ip = conf['leaf1_ip']
leaf2_ip = conf['leaf2_ip']
spine_ip = conf['spine_ip']
apic_passwd = conf.get('apic_passwd')
heat_temp_test = conf['main_setup_heat_temp']
num_hosts = conf['num_comp_nodes']
heat_stack_name = conf['heat_dp_stack_name']
pausetodebug = conf['pausetodebug']
test_parameters = conf['test_parameters']
plugin = conf['plugin-type']
CONTAINERIZED_SERVICES=conf.get('containerized_services', [])
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
hdlr.setFormatter(formatter)
# Add the handler to the logger
LOG.addHandler(hdlr)
apicsystemID = conf['apic_system_id']
nova_agg = conf['nova_agg_name']
nova_az = conf['nova_az_name']
az_node = conf['az_comp_node']
network_node = conf['network_node']
comp_node = conf['compute-2']
cntlr_ip = conf['controller_ip']
extgw = conf['ext_rtr']
priL3Out = conf['primary_L3out']
secL3Out = conf['secondary_L3out']
priL3OutNet=conf.get('primary_L3out_net')
secL3OutNet=conf.get('secondary_L3out_net')
apic_ip = conf['apic_ip']
leaf1_ip = conf['leaf1_ip']
leaf2_ip = conf['leaf2_ip']
spine_ip = conf['spine_ip']
plugin = conf['plugin-type']
if plugin:
from libs.neutron import *
neutron = neutronCli(cntlr_ip)
dnat_heat_temp = conf['preexist_dnat_temp']
dnat_heat_temp = conf['dnat_heat_temp']
#SNAT: Prexisting L3Out in Common, Ext-Seg being tenant-specific
#will result in tenant-specific NAT-EPG where SNAT EPs will get
#learned. Apparently thats will cause inconsistency and we should
#not support such config. Discussed with Amit
