def get_connection_handle(self):
self.inputs = ContrailTestInit(self.ini_file,logger=self.logger)
self.inputs.setUp()
self.connections= ContrailConnections(self.inputs, self.logger)
self.connections.get_vnc_lib_h() # will set self.vnc_lib in the object
self.auth = self.connections.get_auth_h()
def get_inputs(self, project_fixture):
project_inputs = ContrailTestInit(
self.ini_file,
stack_user=project_fixture.project_username,
stack_password=project_fixture.project_user_password,
stack_tenant=self.project_name,
logger=self.logger)
return project_inputs
def get_auth_url():
cti_obj = ContrailTestInit(input_file='contrail_test_input.yaml')
cmd = ["juju status | grep 5000 | awk '{print $5}'"]
auth_ip, err = Util.execute_cmds_on_remote(ip=cti_obj.juju_server,
cmd_list=cmd)
auth_ip = auth_ip.strip()
auth_url = 'http://%s:5000/v3' % auth_ip
return auth_url
def get_inputs(self, project_fixture):
project_inputs = ContrailTestInit(
self.ini_file,
stack_user=project_fixture.username,
stack_password=project_fixture.password,
project_fq_name=['default-domain', self.project_name],
logger=self.logger)
return project_inputs
def get_connections_handle(self):
self.inputs = ContrailTestInit(self.input_file, logger=self.logger)
self.connections = ContrailConnections(self.inputs, self.logger)
self.vnc_lib = self.connections.vnc_lib
self.auth = self.connections.auth
self.lib_handle = ConfigScale(self.inputs, self.logger,
self.connections, self.vnc_lib,
self.auth)
def get_inputs(self):
self.project_inputs = self.useFixture(
ContrailTestInit(
self.ini_file,
stack_user=self.project.username,
stack_password=self.project.password,
project_fq_name=['default-domain', self.project_name],
logger=self.logger))
return self.project_inputs
def setUpClass(cls):
if hasattr(super(BaseTestCase, cls), 'setUpClass'):
super(BaseTestCase, cls).setUpClass()
cls.setUpClassCalled = True
if 'TEST_CONFIG_FILE' in os.environ:
cls.ini_file = os.environ.get('TEST_CONFIG_FILE')
else:
cls.ini_file = 'sanity_params.ini'
cls.logger = contrail_logging.getLogger(cls.__name__)
cls.inputs = ContrailTestInit(cls.ini_file, logger=cls.logger)
def get_inputs(self, username=None, password=None):
username = username or self.project_username or self.inputs.stack_user
password = password or self.project_user_password or self.inputs.stack_password
if username not in self.project_inputs:
self.project_inputs[username] = ContrailTestInit(self.inputs.ini_file,
stack_domain=self.orch_domain_name,
stack_user=username,
stack_password=password,
stack_tenant=self.project_name,
logger=self.logger)
return self.project_inputs[username]
def setUp(self):
super(AnalyticsScaleTest, self).setUp()
if 'PARAMS_FILE' in os.environ:
self.ini_file = os.environ.get('PARAMS_FILE')
else:
self.ini_file = 'params.ini'
self.inputs = self.useFixture(ContrailTestInit(self.ini_file))
self.connections = ContrailConnections(self.inputs)
self.logger = self.inputs.logger
self.analytics_obj = self.connections.analytics_obj
self.ops_inspect = self.connections.ops_inspect
def __init__(self, inputs=None, logger=None, project_name=None,
username=None, password=None, domain_name=None, ini_file=None):
self.inputs = inputs or ContrailTestInit(ini_file,
stack_tenant=project_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.api_server_inspects = custom_dict(self.get_api_inspect_handle,
'api_inspect:'+self.project_name+':'+self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(self.get_opserver_inspect_handle,
'ops_inspect')
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.ds_inspect = custom_dict(self.get_discovery_service_inspect_handle,
'ds_inspect')
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.vnc_lib = self.get_vnc_lib_h()
self.auth = self.get_auth_h()
if self.inputs.orchestrator == 'openstack':
self.project_id = self.get_project_id()
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name, username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(username=self.username,
password=self.password,
project_id=self.project_id,
project_name=self.project_name,
inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_server_ip=self.inputs.auth_ip)
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
else: # vcenter
self.orch = VcenterOrchestrator(user=self.username,
pwd=self.password,
host=self.inputs.auth_ip,
port=self.inputs.auth_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
def setUp(self):
super(VPCSanityTests, self).setUp()
if 'PARAMS_FILE' in os.environ:
self.ini_file = os.environ.get('PARAMS_FILE')
else:
self.ini_file = 'params.ini'
self.inputs = self.useFixture(ContrailTestInit(self.ini_file))
self.connections = ContrailConnections(self.inputs)
self.quantum_h = self.connections.quantum_h
self.nova_h = self.connections.nova_h
self.agent_inspect_h = self.connections.agent_inspect
self.logger = self.inputs.logger
def get_project_inputs(self, username=None, password=None):
if not username:
username = self.username
if not password:
password = self.password
self.project_inputs = ContrailTestInit(
self.inputs.ini_file,
stack_user=username,
stack_password=password,
project_fq_name=['default-domain', self.project_name],
logger=self.logger)
self.project_inputs.setUp()
return self.project_inputs
def setUp(self):
if 'PARAMS_FILE' in os.environ:
self.ini_file = os.environ.get('PARAMS_FILE')
else:
self.ini_file = 'params.ini'
self.inputs = ContrailTestInit(self.ini_file)
self.inputs.setUp()
self.connections = ContrailConnections(self.inputs)
self.quantum_h = self.connections.quantum_h
self.nova_h = self.connections.nova_h
self.vnc_lib = self.connections.vnc_lib
self.logger = self.inputs.logger
return self
def setUp(self):
super(SecurityGroupSanityTestsBase, self).setUp()
if 'PARAMS_FILE' in os.environ:
self.ini_file = os.environ.get('PARAMS_FILE')
else:
self.ini_file = 'params.ini'
self.inputs = self.useFixture(ContrailTestInit(self.ini_file))
self.connections = ContrailConnections(self.inputs)
self.quantum_h = self.connections.quantum_h
self.nova_h = self.connections.nova_h
self.vnc_lib = self.connections.vnc_lib
self.logger = self.inputs.logger
self.analytics_obj = self.connections.analytics_obj
def main():
init_obj = ContrailTestInit(sys.argv[1])
init_obj.read_prov_file()
if init_obj.inputs.vcenter_gw_setup:
vcenter = get_vcenter_server_details(init_obj.inputs)
vcenter_orch = VcenterOrchestrator(init_obj.inputs,
vcenter.server,
vcenter.port,
vcenter.user,
vcenter.password,
init_obj.inputs.vcenter_dc,
logger=log)
vcenter_orch._nfs_ds.delete_datastore()
def setUp(self):
super(Upgradeonly, self).setUp()
if 'PARAMS_FILE' in os.environ:
self.ini_file = os.environ.get('PARAMS_FILE')
else:
self.ini_file = 'params.ini'
self.inputs = self.useFixture(ContrailTestInit(self.ini_file))
self.connections = ContrailConnections(self.inputs)
self.agent_inspect = self.connections.agent_inspect
self.quantum_h = self.connections.quantum_h
self.nova_h = self.connections.nova_h
self.vnc_lib = self.connections.vnc_lib
self.logger = self.inputs.logger
self.analytics_obj = self.connections.analytics_obj
def setUp(self):
super(SolnSetup, self).setUp()
if 'PARAMS_FILE' in os.environ:
self.ini_file = os.environ.get('PARAMS_FILE')
else:
self.ini_file = 'params.ini'
self.inputs = ContrailTestInit(self.ini_file)
self.connections = ContrailConnections(self.inputs)
self.quantum_h = self.connections.quantum_h
self.nova_h = self.connections.nova_h
self.vnc_lib = self.connections.vnc_lib
self.logger = self.inputs.logger
self.setup_common_objects()
return self
def setUp(self):
super(PerformanceSanity, self).setUp()
if 'TEST_CONFIG_FILE' in os.environ:
self.input_file = os.environ.get('TEST_CONFIG_FILE')
else:
self.input_file = 'params.ini'
self.inputs = ContrailTestInit(self.input_file)
self.connections = ContrailConnections(self.inputs)
self.agent_inspect = self.connections.agent_inspect
self.quantum_h = self.connections.quantum_h
self.nova_h = self.connections.nova_h
self.vnc_lib = self.connections.vnc_lib
self.logger = self.inputs.logger
self.analytics_obj = self.connections.analytics_obj
def setUpClass(cls):
# Create the required users, projects and domains
cmd = 'kubectl config use-context juju-context'
cti_obj = ContrailTestInit(input_file='contrail_test_input.yaml')
cti_obj.run_cmd_on_server(server_ip=cti_obj.juju_server,
username='******',
password='******',
issue_cmd=cmd)
super(TestPolicyCombo, cls).setUpClass()
cls.admin = ExampleUser.admin()
cls.admin.create_all(user_name='userD',
password='******',
role='Member',
project_name='userD_project',
domain_name='userD_domain')
cls.admin.create_all(user_name='userA',
password='******',
role='Member',
project_name='userA_project',
domain_name='userA_domain')
cls.admin.create_all(user_name='userB',
password='******',
role='Member',
project_name='userB_project',
domain_name='userB_domain')
cls.admin.create_all(user_name='userC',
password='******',
role='Member',
project_name='userC_project',
domain_name='userC_domain')
cmd = 'kubectl create ns zomsrc; kubectl create ns easy'
cls.inputs.run_cmd_on_server(server_ip=cti_obj.juju_server,
username='******',
password='******',
issue_cmd=cmd)
admin_policy = create_policy.get_admin_policy()
userA_policy = create_policy.get_userA_policy()
userB_policy = create_policy.get_userB_policy()
userC_policy = create_policy.get_userC_policy()
userD_policy = create_policy.get_userD_policy()
policies = [
admin_policy, userA_policy, userB_policy, userC_policy,
userD_policy
]
filename = create_policy.insert_policies_in_template_file(
policies, filename='all_in_one_policy.yaml', inputs=cls.inputs)
create_policy.apply_policies_and_check_in_config_map(
policies, filename, cti_obj.juju_server)
def setup_test_infra(testbed_file):
import logging
from common.log_orig import ContrailLogger
logging.getLogger('urllib3.connectionpool').setLevel(logging.WARN)
logging.getLogger('paramiko.transport').setLevel(logging.WARN)
logging.getLogger('keystoneclient.session').setLevel(logging.WARN)
logging.getLogger('keystoneclient.httpclient').setLevel(logging.WARN)
logging.getLogger('neutronclient.client').setLevel(logging.WARN)
logger = ContrailLogger('verify')
logger.setUp()
mylogger = logger.logger
inputs = ContrailTestInit(testbed_file, logger=mylogger)
inputs.setUp()
connections = ContrailConnections(inputs=inputs, logger=mylogger)
return connections
def setup_test_infra():
import logging
from common.contrail_test_init import ContrailTestInit
from common.connections import ContrailConnections
from common.log_orig import ContrailLogger
logging.getLogger('urllib3.connectionpool').setLevel(logging.WARN)
logging.getLogger('paramiko.transport').setLevel(logging.WARN)
logging.getLogger('keystoneclient.session').setLevel(logging.WARN)
logging.getLogger('keystoneclient.httpclient').setLevel(logging.WARN)
logging.getLogger('neutronclient.client').setLevel(logging.WARN)
logger = ContrailLogger('event')
logger.setUp()
mylogger = logger.logger
inputs = ContrailTestInit('./sanity_params.ini', logger=mylogger)
connections = ContrailConnections(inputs=inputs, logger=mylogger)
return connections
def setUp(self):
super(AnalyticsTestPerformance, self).setUp()
if 'PARAMS_FILE' in os.environ:
self.ini_file = os.environ.get('PARAMS_FILE')
else:
self.ini_file = 'params.ini'
self.inputs = self.useFixture(ContrailTestInit(self.ini_file))
self.connections = ContrailConnections(self.inputs)
self.quantum_h = self.connections.quantum_h
self.nova_h = self.connections.nova_h
self.vnc_lib = self.connections.vnc_lib
self.logger = self.inputs.logger
self.agent_inspect = self.connections.agent_inspect
self.cn_inspect = self.connections.cn_inspect
self.analytics_obj = self.connections.analytics_obj
self.sender_list = []
self.receiver_list = []
def setUp(self):
super(SecurityGroupSetup, self).setUp()
if 'PARAMS_FILE' in os.environ:
self.ini_file = os.environ.get('PARAMS_FILE')
else:
self.ini_file = 'params.ini'
self.inputs = self.useFixture(ContrailTestInit(self.ini_file))
self.connections = ContrailConnections(self.inputs)
self.quantum_h = self.connections.quantum_h
self.nova_h = self.connections.nova_h
self.vnc_lib = self.connections.vnc_lib
self.logger = self.inputs.logger
self.logger.info("Configuring setup for security group tests.")
self.setup()
self.logger.info("Verifying setup of security group tests.")
self.verify()
self.logger.info(
"Finished configuring setup for security group tests.")
return self
def main():
init_obj = ContrailTestInit(sys.argv[1])
if init_obj.inputs.vcenter_gw_setup or (init_obj.inputs.orchestrator
== 'vcenter'):
vcenter = get_vcenter_server_details(init_obj.inputs)
vcenter_orch = VcenterOrchestrator(init_obj.inputs,
vcenter.server,
vcenter.port,
vcenter.user,
vcenter.password,
init_obj.inputs.vcenter_dc,
logger=log)
images = [
'ubuntu', 'ubuntu-traffic', 'vcenter_tiny_vm', 'tiny_nat_fw',
'tiny_in_net'
]
for image in images:
try:
vcenter_orch.load_and_register_template(image)
except:
log.info('Not able to load template %s' % image)
def __init__(self,
inputs=None,
logger=None,
project_name=None,
username=None,
password=None,
domain_name=None,
input_file=None,
domain_obj=None,
scope='domain'):
self.inputs = inputs or ContrailTestInit(input_file,
stack_tenant=project_name)
self.project_name = project_name or self.inputs.project_name
self.domain_name = domain_name or self.inputs.domain_name
self.orch_domain_name = domain_name or self.inputs.domain_name
if self.orch_domain_name == 'Default':
self.domain_name = 'default-domain'
self.scope = scope
self.username = username or self.inputs.stack_user
self.password = password or self.inputs.stack_password
self.logger = logger or self.inputs.logger
self.nova_h = None
self.quantum_h = None
self.vnc_lib_fixture = None
self.api_server_inspects = custom_dict(
self.get_api_inspect_handle,
'api_inspect:' + self.project_name + ':' + self.username)
self.dnsagent_inspect = custom_dict(self.get_dns_agent_inspect_handle,
'dns_inspect')
self.agent_inspect = custom_dict(self.get_vrouter_agent_inspect_handle,
'agent_inspect')
self.ops_inspects = custom_dict(
self.get_opserver_inspect_handle,
'ops_inspect:' + self.project_name + ':' + self.username)
self.cn_inspect = custom_dict(self.get_control_node_inspect_handle,
'cn_inspect')
self.k8s_client = self.get_k8s_api_client_handle()
# ToDo: msenthil/sandipd rest of init needs to be better handled
self.domain_id = None
if self.inputs.domain_isolation:
#get admin auth to list domains and get domain_id
auth = self.get_auth_h(username=self.inputs.admin_username,
password=self.inputs.admin_password,
project_name=self.inputs.admin_tenant,
domain_name=self.inputs.admin_domain)
self.domain_id = auth.get_domain_id(self.domain_name)
self.auth = self.get_auth_h()
self.vnc_lib = self.get_vnc_lib_h()
self.project_id = self.get_project_id()
if self.inputs.orchestrator == 'openstack':
if self.inputs.verify_thru_gui():
self.ui_login = UILogin(self, self.inputs, project_name,
username, password)
self.browser = self.ui_login.browser
self.browser_openstack = self.ui_login.browser_openstack
self.orch = OpenstackOrchestrator(inputs=self.inputs,
vnclib=self.vnc_lib,
logger=self.logger,
auth_h=self.auth)
self.nova_h = self.orch.get_compute_handler()
self.quantum_h = self.orch.get_network_handler()
self.glance_h = self.orch.get_image_handler()
elif self.inputs.orchestrator == 'vcenter' and self.inputs.slave_orchestrator == 'vro':
self.orch = VroWorkflows(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
elif self.inputs.orchestrator == 'vcenter': # vcenter
self.orch = VcenterOrchestrator(user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=self.inputs.vcenter_port,
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
elif self.inputs.orchestrator == 'kubernetes':
self.orch = None
if self.inputs.vcenter_gw_setup: # vcenter_gateway
self.slave_orch = VcenterGatewayOrch(
user=self.inputs.vcenter_username,
pwd=self.inputs.vcenter_password,
host=self.inputs.vcenter_server,
port=int(self.inputs.vcenter_port),
dc_name=self.inputs.vcenter_dc,
vnc=self.vnc_lib,
inputs=self.inputs,
logger=self.logger)
self._kube_manager_inspect = None
def main():
inputs = ContrailTestInit(sys.argv[1])
host = sys.argv[2] if len(sys.argv) > 2 else None
role = sys.argv[3] if len(sys.argv) > 3 else None
service = sys.argv[4] if len(sys.argv) > 4 else None
contrail_status(inputs, host, role, service)
import ConfigParser
import ast
import logging
from tor_fixture import ToRFixtureFactory
from physical_router_fixture import PhysicalRouterFixture
from common.contrail_test_init import ContrailTestInit
from physical_device_fixture import PhysicalDeviceFixture
from vcpe_router_fixture import VpeRouterFixture
from virtual_router_fixture import VirtualRouterFixture
logging.getLogger('urllib3.connectionpool').setLevel(logging.WARN)
logging.getLogger('paramiko.transport').setLevel(logging.WARN)
if __name__ == "__main__":
init_obj = ContrailTestInit(sys.argv[1])
for (device, device_dict) in init_obj.physical_routers_data.iteritems():
if device_dict['type'] == 'tor':
tor_obj = ToRFixtureFactory.get_tor(
device_dict['name'],
device_dict['mgmt_ip'],
vendor=device_dict['vendor'],
ssh_username=device_dict['ssh_username'],
ssh_password=device_dict['ssh_password'],
tunnel_ip=device_dict['tunnel_ip'],
ports=device_dict['ports'],
tor_ovs_port=device_dict['tor_ovs_port'],
tor_ovs_protocol=device_dict['tor_ovs_protocol'],
controller_ip=device_dict['controller_ip'],
cfgm_ip=init_obj.cfgm_ip,
auth_server_ip=init_obj.auth_ip,
else:
self.delete()
if __name__ == "__main__":
from tcutils.util import *
pol1 = [{
'action': 'deny',
'source': '0.0.0.0',
'group': '225.1.1.1'
}, {
'action': 'deny',
'source': '0.0.0.0',
'group': '225.1.1.2'
}]
from common.contrail_test_init import ContrailTestInit
from common.connections import ContrailConnections
from common.log_orig import ContrailLogger
logger = ContrailLogger('event')
logger.setUp()
mylogger = logger.logger
inputs = ContrailTestInit('./instances.yaml', logger=mylogger)
connections = ContrailConnections(inputs=inputs, logger=mylogger)
obj = MulticastPolicyFixture(name='test_policy',
policy=pol1,
connections=connections)
obj.setUp()
obj.cleanUp()
def test_vdns_with_diff_zone(self):
''' Test vdns in different zones with multi projects '''
var_obj = self.InitForZoneTests()
vdns_fixt1 = {}
ipam_mgmt_obj = {}
for project in var_obj.project_list:
dns_server_name = var_obj.proj_vdns[project]
self.logger.info(
'Creating vdns server:%s in project:%s',
dns_server_name,
project)
domain_name = '%s.net' % (project)
ttl = 100
# VDNS creation
dns_data = VirtualDnsType(
domain_name=domain_name, dynamic_records_from_client=True,
default_ttl_seconds=ttl, record_order='random')
vdns_fixt1[project] = self.useFixture(
VdnsFixture(
self.inputs,
self.connections,
vdns_name=dns_server_name,
dns_data=dns_data))
result, msg = vdns_fixt1[project].verify_on_setup()
self.assertTrue(result, msg)
dns_server = IpamDnsAddressType(
virtual_dns_server_name=vdns_fixt1[project].vdns_fq_name)
ipam_mgmt_obj[project] = IpamType(
ipam_dns_method='virtual-dns-server',
ipam_dns_server=dns_server)
ipam_fixt = {}
vn_fixt = {}
vm_fix = {}
pol_fixt = {}
for proj in var_obj.project_list:
# User creation
user_fixture = self.useFixture(
UserFixture(
connections=self.admin_connections,
username=var_obj.proj_user[proj],
password=var_obj.proj_pass[proj]))
# Project creation
project_fixture = self.useFixture(
ProjectFixture(
project_name=proj,
username=var_obj.proj_user[proj],
password=var_obj.proj_pass[proj],
connections=self.admin_connections))
user_fixture.add_user_to_tenant(proj, var_obj.proj_user[proj], 'admin')
project_fixture.set_user_creds(var_obj.proj_user[proj], var_obj.proj_pass[proj])
project_inputs = ContrailTestInit(
self.ini_file,
stack_user=project_fixture.project_username,
stack_password=project_fixture.project_user_password,
stack_tenant=proj,
logger=self.logger)
project_connections = ContrailConnections(project_inputs,
logger=self.logger)
self.logger.info(
'Default SG to be edited for allow all on project: %s' % proj)
project_fixture.set_sec_group_for_allow_all(proj, 'default')
# Ipam creation
ipam_fixt[proj] = self.useFixture(IPAMFixture(var_obj.ipam_list[proj], vdns_obj= vdns_fixt1[proj].obj,
project_obj=project_fixture, ipamtype=ipam_mgmt_obj[proj]))
# VN Creation
vn_fixt[proj] = self.useFixture(
VNFixture(
project_name=proj,
connections=project_connections,
vn_name=var_obj.vn_list[proj],
inputs=project_inputs,
subnets=var_obj.vn_nets[proj],
ipam_fq_name=ipam_fixt[proj].getObj().get_fq_name()))
vn_quantum_obj = self.orch.get_vn_obj_if_present(vn_name=var_obj.vn_list[proj], project_id=project_fixture.uuid)
# VM creation
vm_fix[proj] = self.useFixture(
VMFixture(
project_name=proj,
connections=project_connections,
vn_obj=vn_quantum_obj,
vm_name=var_obj.vm_list[proj]))
vm_fix[proj].verify_vm_launched()
vm_fix[proj].verify_on_setup()
vm_fix[proj].wait_till_vm_is_up()
msg = "Ping by using name %s is failed. Dns server \
should resolve VM name to IP" % (var_obj.vm_list[proj])
self.assertTrue(
vm_fix[proj].ping_with_certainty(ip=var_obj.vm_list[proj]), msg)
vm_ip = vm_fix[proj].get_vm_ip_from_vm(
vn_fq_name=vm_fix[proj].vn_fq_name)
vm_rev_ip = vm_ip.split('.')
vm_rev_ip = '.'.join(
(vm_rev_ip[3], vm_rev_ip[2], vm_rev_ip[1], vm_rev_ip[0]))
vm_rev_ip = vm_rev_ip + '.in-addr.arpa'
rev_zone = var_obj.vn_nets[proj][0].split('/')[0].split('.')
rev_zone = '.'.join((rev_zone[0], rev_zone[1], rev_zone[2]))
rev_zone = rev_zone + '.in-addr.arpa'
# Frame the Expected DNS data for VM, one for 'A' record and
# another 'PTR' record.
domain_name = '%s.net' % (proj)
rec_name = var_obj.vm_list[proj] + "." + domain_name
agent_inspect_h = self.agent_inspect[vm_fix[proj].vm_node_ip]
assigned_dns_ips = agent_inspect_h.get_vna_discovered_dns_server()
vm_dns_exp_data = [{'rec_data': vm_ip,
'rec_type': 'A',
'rec_class': 'IN',
'rec_ttl': str(ttl),
'rec_name': rec_name,
'installed': 'yes',
'zone': domain_name},
{'rec_data': rec_name,
'rec_type': 'PTR',
'rec_class': 'IN',
'rec_ttl': str(ttl),
'rec_name': vm_rev_ip,
'installed': 'yes',
'zone': rev_zone}]
self.verify_vm_dns_data(vm_dns_exp_data, assigned_dns_ips[0])
vm_dns_exp_data = []
self.logger.info(
'Restart supervisor-config & supervisor-control and test ping')
for bgp_ip in self.inputs.bgp_ips:
self.inputs.restart_service('supervisor-control', [bgp_ip],
container='controller')
for cfgm_ip in self.inputs.cfgm_ips:
self.inputs.restart_service('supervisor-config', [cfgm_ip],
container='controller')
status_checker = ContrailStatusChecker(self.inputs)
self.logger.debug("Waiting for all the services to be UP")
assert status_checker.wait_till_contrail_cluster_stable()[0],\
"All services could not come UP after restart"
for proj in var_obj.project_list:
msg = "Ping by using name %s is failed. Dns server \
should resolve VM name to IP" % (var_obj.vm_list[proj])
self.assertTrue(
vm_fix[proj].ping_with_certainty(ip=var_obj.vm_list[proj]), msg)
return True
import unittest
from common.contrail_test_init import ContrailTestInit
from tcutils.contrailtestrunner import ContrailHTMLTestRunner
from tcutils.util import get_os_env
from sanity import VPCSanityTests
if __name__ == "__main__":
if not get_os_env('SCRIPT_TS'):
os.environ['SCRIPT_TS'] = time.strftime("%Y_%m_%d_%H_%M_%S")
if 'PARAMS_FILE' in os.environ:
ini_file = os.environ.get('PARAMS_FILE')
else:
ini_file = 'params.ini'
inputs = ContrailTestInit(ini_file)
inputs.setUp()
print "\nTest Log File : %s" % (inputs.log_file)
loader = unittest.TestLoader()
suite = unittest.TestSuite()
suite.addTests(loader.loadTestsFromTestCase(eval('VPCSanityTests')))
test_result = unittest.TestResult()
descr = inputs.get_html_description()
if inputs.generate_html_report:
buf = open(inputs.html_report, 'w')
runner = ContrailHTMLTestRunner(stream=buf,
title='%s Result %s' %
(inputs.log_scenario, inputs.build_id),
