class SolnSetup(object): def __init__(self, test_resource): self.test_resource = test_resource 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 # end setUp def tearDown(self): pass def dirtied(self): self.test_resource.dirtied(self)
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 main(): init_obj = ContrailTestInit(sys.argv[1]) init_obj.read_prov_file() 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 ) vcenter_orch._nfs_ds.delete_datastore()
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 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 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 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 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_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_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_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 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 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(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 __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(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 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
class ConfigScaleSetup: def __init__(self): self.ini_file = "sanity_params.ini" self.log_name = "tor-scale.log" Logger = logging.ContrailLogger(self.log_name) Logger.setUp() self.logger = Logger.logger 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 config_test(self): self.get_connection_handle() tenant_name = "tenant" + "".join([random.choice(string.ascii_uppercase + string.digits) for i in xrange(10)]) project_obj = Project(self.connections) project_obj.create(tenant_name)
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
class ConfigScaleSetup: def __init__(self): self.ini_file= 'sanity_params.ini' self.log_name='tor-scale.log' Logger = logging.ContrailLogger(self.log_name) Logger.setUp() self.logger = Logger.logger 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 config_test(self): self.get_connection_handle() tenant_name = "tenant" + "".join([random.choice(string.ascii_uppercase + string.digits) for i in xrange(10)]) project_obj = Project(self.connections) project_obj.create(tenant_name)
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 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)
import os import re import sys import logging from common.contrail_test_init import ContrailTestInit logging.getLogger('paramiko.transport').setLevel(logging.WARN) if __name__ == "__main__": init_obj = ContrailTestInit(sys.argv[1]) ips = set(init_obj.cfgm_ips + init_obj.collector_ips) collected = {} for host_ip in ips: # copy the python script script_file = 'search-bt.py' ignore_tb_file = 'ignore_tracebacks.json' src_file = 'tools/%s' % (script_file) src_ignore_tb_file = 'tools/%s' % (ignore_tb_file) dest = '/tmp' containers = ['controller', 'analytics'] for container in containers: if not init_obj.host_data[host_ip].get('containers', {}).get(container): container_str = '' else: container_str = container if collected.get('%s-%s' % (host_ip, container_str)): continue
import os import sys import json import ConfigParser import ast from tor_fixture import ToRFixtureFactory from physical_router_fixture import PhysicalRouterFixture from common.contrail_test_init import ContrailTestInit if __name__ == "__main__": init_obj = ContrailTestInit(sys.argv[1]) init_obj.read_prov_file() 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'], bringup=True) tor_obj.setUp() if device_dict['type'] == 'router': phy_router_obj = PhysicalRouterFixture( device_dict['name'], device_dict['mgmt_ip'],
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 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
from tests import TestSanityFixture from securitygroup.sanity import SecurityGroupSanityTests from servicechain.firewall.sanity_with_setup import SvcMonSanityFixture from common.contrail_test_init import ContrailTestInit from tcutils.contrailtestrunner import ContrailHTMLTestRunner 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) suite = unittest.TestSuite() test_result = unittest.TestResult() suite.addTest(Upgrade('test_fiptraffic_before_upgrade')) suite.addTest(Upgrade('test_upgrade')) suite.addTest(Upgrade('test_traffic_after_upgrade')) suite.addTest(TestVMVN('test_vn_add_delete')) suite.addTest(TestVMVN('test_vm_add_delete')) suite.addTest(TestVMVN('test_ipam_add_delete')) suite.addTest(TestSanityFixture('test_project_add_delete')) suite.addTest(SecurityGroupSanityTests('test_sec_group_add_delete')) suite.addTest(SvcMonSanityFixture('test_svc_in_network_datapath')) suite.addTest(SvcMonSanityFixture('test_svc_transparent_with_3_instance')) descr = inputs.get_html_description()
import ConfigParser import ast import logging 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.get('role') in ['leaf', 'spine']: continue phy_router_obj = PhysicalRouterFixture( device_dict['name'], device_dict['mgmt_ip'], asn=device_dict['asn'], model=device_dict.get('model', 'mx'), vendor=device_dict.get('vendor', 'juniper'), ssh_username=device_dict.get('ssh_username'), ssh_password=device_dict.get('ssh_password'), tunnel_ip=device_dict.get('tunnel_ip'), ports=device_dict.get('ports'), dm_managed=device_dict.get('dm_managed'), tsn=device_dict.get('tsn'),
import sys #import json #import ConfigParser import logging from fabric.context_managers import settings from fabric.operations import put from common.contrail_test_init import ContrailTestInit logging.getLogger('urllib3.connectionpool').setLevel(logging.WARN) logging.getLogger('paramiko.transport').setLevel(logging.WARN) CONTRAIL_CONF_PATH = '/etc/contrail' if __name__ == "__main__": init_obj = ContrailTestInit(sys.argv[1]) if init_obj.tor_agent_data: print('Configuring any cert files required for tor-agents') else: print('No tor-agents in the setup, no cert files will be configured') sys.exit(0) for ta_host_string, ta_list in init_obj.tor_agent_data.iteritems(): (user, ip) = ta_host_string.split('@') password = init_obj.host_data[ip]['password'] with settings(host_string=ta_host_string, password=password): # Copy cacert.pem cacert_file = '%s/ssl/certs/cacert.pem' % (CONTRAIL_CONF_PATH) put('tools/tor/cacert.pem', cacert_file) for tor_agent in ta_list: if tor_agent.get('tor_ovs_protocol') != 'pssl':
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]) init_obj.read_prov_file() 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,
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,
import sys #import json #import ConfigParser import logging from fabric.context_managers import settings from fabric.operations import put from common.contrail_test_init import ContrailTestInit logging.getLogger('urllib3.connectionpool').setLevel(logging.WARN) logging.getLogger('paramiko.transport').setLevel(logging.WARN) CONTRAIL_CONF_PATH = '/etc/contrail' if __name__ == "__main__": init_obj = ContrailTestInit(sys.argv[1]) init_obj.read_prov_file() if init_obj.tor_agent_data: print 'Configuring any cert files required for tor-agents' else: print 'No tor-agents in the setup, no cert files will be configured' sys.exit(0) for ta_host_string, ta_list in init_obj.tor_agent_data.iteritems(): (user, ip) = ta_host_string.split('@') password = init_obj.host_data[ip]['password'] with settings(host_string=ta_host_string, password=password): # Copy cacert.pem cacert_file = '%s/ssl/certs/cacert.pem' % (CONTRAIL_CONF_PATH) put('tools/tor/cacert.pem', cacert_file) for tor_agent in ta_list:
class ProjectFixture(fixtures.Fixture): def __init__(self, connections, project_name=None, username=None, password=None, role='admin', domain_name=None, uuid=None): self.inputs = connections.inputs if not project_name: project_name = self.inputs.stack_tenant self.connections = connections self.project_name = project_name self.domain_name = domain_name or self.inputs.domain_name self.logger = connections.inputs.logger self.username = username or self.inputs.stack_user self.password = password or self.inputs.stack_password self.role = role self.user_dict = {} self._create_user_set = {} self.auth = self.connections.get_auth_h() self.vnc_lib_h = self.connections.get_vnc_lib_h() self.already_present = False self.verify_is_run = False self.project_fq_name = [self.domain_name, self.project_name] if uuid: self.project_obj = self.vnc_lib_h.project_read(id=uuid) self.project_name = self.project_obj.name self.project_fq_name = self.project_obj.get_fq_name() self.uuid = uuid # end __init__ def _create_project(self): if self.project_name == self.inputs.stack_tenant: self.uuid = self.auth.get_project_id(self.domain_name, self.project_name) if not self.uuid: self.logger.info('Project %s not found' % ( self.project_name)) raise Exception('Project %s not found' % ( self.project_name)) self.already_present = True self.logger.debug( 'Project %s already present.Not creating it' % self.project_fq_name) self.project_obj = self.vnc_lib_h.project_read(id=self.uuid) return self.connections.inputs.domain_name = self.domain_name self.connections.project_name = self.project_name self.logger.info('Proceed with creation of new project.') #if self.domain_name: # try: # dom_obj = self.connections.vnc_lib.domain_read(fq_name=[self.domain_name]) # except: #d_obj = Domain(self.domain_name) # d_obj.set_domain_limits(gen.resource_xsd.DomainLimitsType.populate()) # d_obj.set_id_perms(gen.resource_xsd.IdPermsType.populate()) # d_obj.set_perms2(gen.resource_xsd.PermType2.populate()) #domain_id = self.connections.vnc_lib.domain_create(d_obj) #sys.exit() #dom_obj = self.connections.vnc_lib.domain_read(id=domain_id) #if self.domain_name: #pobj = Project(self.project_name,parent_obj=dom_obj) #else: # pobj = Project(self.project_name) #pobj = Project(self.project_name) #self.uuid = self.connections.vnc_lib.project_create(pobj) self.uuid = self.auth.create_project(self.project_name) self.logger.info('Created Project:%s, ID : %s ' % (self.project_name, self.uuid)) # end _create_project def _delete_project(self): self.logger.info('Deleting Project %s' % self.project_fq_name) self.auth.delete_project(self.project_name) # end _delete_project def setUp(self): super(ProjectFixture, self).setUp() self._create() def _create(self): self.uuid = self.auth.get_project_id(self.domain_name, self.project_name) if self.uuid: self.already_present = True self.logger.debug( 'Project %s already present.Not creating it' % self.project_fq_name) else: self.logger.info('Project %s not found, creating it' % ( self.project_name)) self._create_project() time.sleep(2) self.project_obj = self.vnc_lib_h.project_read(id=self.uuid) # end setUp def get_uuid(self): return self.uuid def get_fq_name(self): return self.project_fq_name def getObj(self): return getattr(self, 'project_obj', None) def cleanUp(self): super(ProjectFixture, self).cleanUp() self.delete() def delete(self, verify=False): if self.inputs.orchestrator == 'vcenter': self.logger.debug('No need to verify projects in case of vcenter') return do_cleanup = True if self.inputs.fixture_cleanup == 'no': do_cleanup = False if self.already_present: do_cleanup = False if self.inputs.fixture_cleanup == 'force': do_cleanup = True if do_cleanup: if not self.check_no_project_references(): self.logger.warn('One or more references still present' ', will not delete the project %s' % (self.project_name)) return self.auth.reauth() self._delete_project() if self.verify_is_run or verify: assert self.verify_on_cleanup() else: self.logger.debug('Skipping the deletion of Project %s' % self.project_fq_name) # end cleanUp @retry(delay=2, tries=10) def check_no_project_references(self): vnc_project_obj = self.vnc_lib_h.project_read(id=self.uuid) vns = vnc_project_obj.get_virtual_networks() if vns: self.logger.warn('Project %s still has VNs %s before deletion' %( self.project_name, vns)) return False vmis = vnc_project_obj.get_virtual_machine_interfaces() if vmis: self.logger.warn('Project %s still has VMIs %s before deletion' %( self.project_name, vmis)) return False sgs = vnc_project_obj.get_security_groups() if sgs and len(sgs) > 1: self.logger.warn('Project %s still has SGs %s before deletion' %( self.project_name, sgs)) return False return True # end check_no_project_references 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 get_project_connections(self, username=None, password=None): if not username: username = self.username if not password: password = self.password project_inputs = self.get_project_inputs() if not getattr(self, 'project_connections', None): self.project_connections = ContrailConnections( inputs=project_inputs, logger=project_inputs.logger, project_name=self.project_name, username=username, password=password) return self.project_connections # end get_project_connections def verify_on_setup(self): result = True if not self.verify_project_in_api_server(): result &= False self.logger.error('Verification of project %s in APIServer ' 'failed!! ' % (self.project_name)) self.verify_is_run = True return result # end verify_on_setup @retry(delay=2, tries=6) def verify_project_in_api_server(self): if self.inputs.orchestrator == 'vcenter': self.logger.debug('No need to verify projects in case of vcenter') return True result = True api_server_inspect_handles = self.connections.get_api_server_inspect_handles() for api_s_inspect in api_server_inspect_handles.values(): cs_project_obj = api_s_inspect.get_cs_project(self.domain_name, self.project_name) if not cs_project_obj: self.logger.warn('Project %s not found in API Server %s' ' ' % (self.project_name, api_s_inspect._ip)) result &= False return result if cs_project_obj['project']['uuid'] != self.uuid: self.logger.warn('Project id %s got from API Server is' ' not matching expected ID %s' % ( cs_project_obj['project']['uuid'], self.uuid)) result &= False if result: self.logger.info('Verification of project %s in API Server %s' ' passed ' % (self.project_name, api_s_inspect._ip)) return result # end verify_project_in_api_server @retry(delay=10, tries=12) def verify_project_not_in_api_server(self): if self.inputs.orchestrator == 'vcenter': self.logger.debug('No need to verify projects in case of vcenter') return True result = True api_server_inspect_handles = self.connections.get_api_server_inspect_handles() for api_s_inspect in api_server_inspect_handles.values(): cs_project_obj = api_s_inspect.get_cs_project(self.domain_name, self.project_name) self.logger.info("Check for project %s after deletion, got cs_project_obj %s" % (self.project_name, cs_project_obj)) if cs_project_obj: self.logger.warn('Project %s is still found in API Server %s' 'with ID %s ' % (self.project_name, api_s_inspect._ip, cs_project_obj['project']['uuid'])) result &= False if result: self.logger.info('Verification of project %s removal in API Server ' ' %s passed ' % (self.project_name, api_s_inspect._ip)) return result # end verify_project_not_in_api_server def set_sec_group_for_allow_all(self, sg_name='default'): uuid_1 = uuid.uuid1().urn.split(':')[2] uuid_2 = uuid.uuid1().urn.split(':')[2] rule1 = [{'direction': '>', 'protocol': 'any', 'dst_addresses': [{'security_group': 'local', 'subnet': None}], 'dst_ports': [{'start_port': 0, 'end_port': 65535}], 'src_ports': [{'start_port': 0, 'end_port': 65535}], 'src_addresses': [{'subnet': {'ip_prefix': '0.0.0.0', 'ip_prefix_len': 0}}], 'rule_uuid': uuid_1 }, {'direction': '>', 'protocol': 'any', 'src_addresses': [{'security_group': 'local', 'subnet': None}], 'src_ports': [{'start_port': 0, 'end_port': 65535}], 'dst_ports': [{'start_port': 0, 'end_port': 65535}], 'dst_addresses': [{'subnet': {'ip_prefix': '0.0.0.0', 'ip_prefix_len': 0}}], 'rule_uuid': uuid_2 }, ] self.update_sec_group(sg_name, rule1) # end set_sec_group_for_allow_all def update_sec_group(self, sg_name, rules): vnc_lib_h = self.get_project_connections().get_vnc_lib_h() old_rules = vnc_lib_h.get_sg_rules(sg_name) self.logger.info( "Adding rules to the %s security group in Project %s" % (sg_name, self.project_name)) vnc_lib_h.set_sg_rules(sg_name, rules) #self.addCleanup(vnc_lib_h.set_sg_rules, sg_name, old_rules) @retry(delay=2, tries=10) def verify_on_cleanup(self): result = True if not self.verify_project_not_in_api_server(): result &= False self.logger.error('Project %s is still present in API Server' % ( self.project_name)) return result