def get_auth_h(self):
if not getattr(self, 'auth', None):
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.username, self.password, self.project_name, self.inputs, self.logger)
else: # vcenter
self.auth = VcenterAuth(self.username, self.password, self.project_name, self.inputs)
return self.auth
def setUp(self):
super(VncLibFixture, self).setUp()
if self.connections:
self.logger = self.connections.logger
self.project_name = self.connections.project_name
self.inputs = self.connections.inputs
self.neutron_handle = self.connections.quantum_h
self.vnc_api_h = self.connections.vnc_lib
self.username = self.connections.username
self.password = self.connections.password
self.cfgm_ip = self.inputs.cfgm_ip
self.auth_server_ip = self.inputs.auth_ip
self.project_id = self.connections.project_id
self.auth_url = 'http://' + self.inputs.auth_ip + ':5000/v2.0'
else:
self.vnc_api_h = VncApi(username=self.username,
password=self.password,
tenant_name=self.project_name,
api_server_host=self.cfgm_ip,
api_server_port=self.api_server_port,
auth_host=self.auth_server_ip)
if self.orchestrator == 'openstack':
self.auth_client = OpenstackAuth(self.username,
self.password,
self.project_name,
auth_url=self.auth_url,
logger=self.logger)
self.project_id = self.auth_client.get_project_id()
elif self.orchestrator == 'vcenter':
self.auth_client = VcenterAuth(self.username, self.password,
self.project_name, self.inputs)
self.project_id = self.auth_client.get_project_id()
def __init__(self, vnc_lib_h, connections, auth=None, project_name=None,
username=None, password=None, role='admin',
domain_name=None, uuid=None):
self.inputs = connections.inputs
self.vnc_lib_h = connections.get_vnc_lib_h()
self.logger = connections.logger
self.connections = connections
self.auth = auth
self.project_name = project_name or self.inputs.stack_tenant
self.domain_name = domain_name or 'default-domain'
self.uuid = uuid
self.project_obj = None
self.already_present = False
self.project_fq_name = [self.domain_name, self.project_name]
self.username = username
self.password = password
self.role = role
self.user_dict = {}
self._create_user_set = {}
self.project_connections = None
self.api_server_inspects = self.connections.api_server_inspects
self.verify_is_run = False
if not self.auth:
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.inputs.stack_user,
self.inputs.stack_password,
self.inputs.project_name, self.inputs, self.logger)
else: # vcenter
self.auth = VcenterAuth(self.inputs.stack_user,
self.inputs.stack_password,
self.inputs.project_name, self.inputs)
self.project_username = None
self.project_user_password = None
def __init__(self, vnc_lib_h, connections, auth=None, project_name=None,
username=None, password=None, role='admin', scale= False):
self.inputs = connections.inputs
if not project_name:
project_name = self.inputs.stack_tenant
self.vnc_lib_h = vnc_lib_h
self.connections = connections
self.auth = auth
self.project_name = project_name
self.project_obj = None
self.domain_name = 'default-domain'
self.already_present = False
self.logger = connections.inputs.logger
self.project_fq_name = [self.domain_name, self.project_name]
self.username = username
self.password = password
self.role = role
self.user_dict = {}
self._create_user_set = {}
self.project_connections = None
self.api_server_inspects = self.connections.api_server_inspects
self.verify_is_run = False
self.scale = scale
if not self.auth:
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.inputs.stack_user,
self.inputs.stack_password,
self.inputs.project_name, self.inputs, self.logger)
else: # vcenter
self.auth = VcenterAuth(self.inputs.stack_user,
self.inputs.stack_password,
self.inputs.project_name, self.inputs)
def __init__(self, inputs,logger,
project_name=None,
username=None,
password=None):
self.inputs = inputs
project_name = project_name or self.inputs.project_name
username = username or self.inputs.stack_user
password = password or self.inputs.stack_password
self.username = username
self.password = password
self.project_name = project_name
self.logger = logger
self.vnc_lib_fixture = VncLibFixture(
username=username, password=password,
domain=self.inputs.domain_name, project_name=project_name,
inputs = self.inputs,
cfgm_ip=self.inputs.cfgm_ip,
api_server_port=self.inputs.api_server_port,
auth_server_ip=self.inputs.auth_ip,
orchestrator=self.inputs.orchestrator,
logger=self.logger)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
self.nova_h = None
self.quantum_h = None
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(username, password, project_name, self.inputs, logger)
self.project_id = self.auth.get_project_id(project_name)
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=username, password=password,
project_id=self.project_id, project_name=project_name,
inputs=inputs, vnclib=self.vnc_lib, logger=logger,
auth_server_ip=self.inputs.auth_ip)
self.nova_h = self.orch.get_nova_handler()
self.quantum_h = self.orch.get_network_handler()
else: # vcenter
self.auth = VcenterAuth(username, password, project_name, self.inputs)
self.orch = VcenterOrchestrator(user=username, pwd=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=logger)
self.api_server_inspects = {}
self.dnsagent_inspect = {}
self.cn_inspect = {}
self.agent_inspect = {}
self.ops_inspects = {}
self.ds_inspect = {}
self.update_inspect_handles()
def get_auth_h(self):
if not getattr(self, 'auth', None):
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.username, self.password,
self.project_name, self.inputs,
self.logger)
else: # vcenter
self.auth = VcenterAuth(self.username, self.password,
self.project_name, self.inputs)
return self.auth
def __init__(self,
connections,
auth=None,
project_name=None,
username=None,
password=None,
role='admin',
domain_name=None,
uuid=None):
self.inputs = connections.inputs
self.vnc_lib_h = connections.get_vnc_lib_h()
self.vnc_lib_fixture = connections.vnc_lib_fixture
self.logger = connections.logger
self.connections = connections
self.auth = auth
self.project_name = project_name or self.inputs.stack_tenant
self.orch_domain_name = domain_name or self.inputs.stack_domain
if self.orch_domain_name == 'Default':
self.domain_name = 'default-domain'
else:
self.domain_name = self.orch_domain_name
self.domain_id = self.connections.domain_id or 'default'
self.uuid = uuid
self.project_obj = None
self.already_present = False
self.project_fq_name = [self.domain_name, self.project_name]
self.project_username = self.username = username or self.connections.username
self.project_user_password = self.password = password or self.connections.password
self.role = role
self.user_dict = {}
self._create_user_set = {}
self.project_connections = dict()
self.project_inputs = dict()
self.api_server_inspects = self.connections.api_server_inspects
self.verify_is_run = False
if not self.auth:
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.inputs.admin_username,
self.inputs.admin_password,
self.inputs.admin_tenant,
self.inputs,
self.logger,
domain_name=self.inputs.admin_domain)
elif self.inputs.orchestrator == 'vcenter':
self.auth = VcenterAuth(self.inputs.admin_username,
self.inputs.admin_password,
self.inputs.admin_tenant, self.inputs)
else:
# Kubernetes
# Set no auth for now
self.auth = None
def setUp(self):
super(VncLibFixture, self).setUp()
if not self.connections:
self.logger = self.logger or contrail_logging.getLogger(__name__)
self.vnc_api_h = VncApi(username=self.username,
password=self.password,
tenant_name=self.project_name,
domain_name=self.orch_domain,
api_server_host=self.cfgm_ip,
api_server_port=self.api_server_port,
auth_host=self.auth_server_ip,
auth_port=self.auth_port,
api_server_use_ssl=self.use_ssl,
auth_url=self.authn_url)
if self.orchestrator == 'openstack':
self.auth_client = OpenstackAuth(self.username,
self.password,
self.project_name,
domain_name=self.orch_domain,
auth_url=self.auth_url,
certfile=self.certfile,
keyfile=self.keyfile,
cacert=self.cacert,
insecure=self.insecure,
logger=self.logger,
scope='project')
elif self.orchestrator == 'vcenter':
self.auth_client = VcenterAuth(self.username, self.password,
self.project_name, self.inputs)
if self.orch:
self.vnc_h = self.orch.vnc_h
else:
self.vnc_h = ContrailVncApi(self.vnc_api_h, self.logger)
def get_auth_h(self,
refresh=False,
project_name=None,
username=None,
password=None,
domain_name=None):
project_name = project_name or self.project_name
username = username or self.username
password = password or self.password
attr = '_auth_' + project_name + '_' + username
if not getattr(env, attr, None) or refresh:
if self.inputs.orchestrator == 'openstack':
env[attr] = OpenstackAuth(username,
password,
project_name,
self.inputs,
self.logger,
domain_name=domain_name
or self.orch_domain_name,
scope=self.scope)
elif self.inputs.orchestrator == 'vcenter':
env[attr] = VcenterAuth(username, password, project_name,
self.inputs)
# elif self.inputs.orchestrator == 'kubernetes':
# env[attr] = self.get_k8s_api_client_handle()
return env.get(attr)
def __init__(self, connections, auth=None, project_name=None,
username=None, password=None, role='admin',
domain_name=None, uuid=None):
self.inputs = connections.inputs
self.vnc_lib_h = connections.get_vnc_lib_h()
self.vnc_lib_fixture = connections.vnc_lib_fixture
self.logger = connections.logger
self.connections = connections
self.auth = auth
self.project_name = project_name or self.inputs.stack_tenant
self.orch_domain_name = domain_name or self.inputs.stack_domain
if self.orch_domain_name == 'Default':
self.domain_name = 'default-domain'
else:
self.domain_name = self.orch_domain_name
self.domain_id = self.connections.domain_id or 'default'
self.uuid = uuid
self.project_obj = None
self.already_present = False
self.project_fq_name = [self.domain_name, self.project_name]
self.project_username = self.username = username or self.connections.username
self.project_user_password = self.password = password or self.connections.password
self.role = role
self.user_dict = {}
self._create_user_set = {}
self.project_connections = dict()
self.project_inputs = dict()
self.api_server_inspects = self.connections.api_server_inspects
self.verify_is_run = False
if not self.auth:
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.inputs.admin_username,
self.inputs.admin_password,
self.inputs.admin_tenant, self.inputs, self.logger,
domain_name=self.inputs.admin_domain)
elif self.inputs.orchestrator == 'vcenter':
self.auth = VcenterAuth(self.inputs.admin_username,
self.inputs.admin_password,
self.inputs.admin_tenant, self.inputs)
else:
# Kubernetes
# Set no auth for now
self.auth = None
def setUp(self):
super(VncLibFixture, self).setUp()
if self.connections:
self.logger = self.connections.logger
self.project_name = self.connections.project_name
self.inputs = self.connections.inputs
self.neutron_handle = self.connections.quantum_h
self.vnc_api_h = self.connections.vnc_lib
self.username = self.connections.username
self.password = self.connections.password
self.cfgm_ip = self.inputs.cfgm_ip
self.auth_server_ip = self.inputs.auth_ip
self.project_id = self.connections.project_id
self.auth_url = 'http://' + self.inputs.auth_ip + ':5000/v2.0'
else:
self.logger = self.logger or contrail_logging.getLogger(__name__)
self.vnc_api_h = VncApi(
username=self.username,
password=self.password,
tenant_name=self.project_name,
api_server_host=self.cfgm_ip,
api_server_port=self.api_server_port,
auth_host=self.auth_server_ip)
if not self.project_id:
if self.orchestrator == 'openstack':
self.auth_client = OpenstackAuth(
self.username,
self.password,
self.project_name,
auth_url=self.auth_url,
logger=self.logger)
self.project_id = self.auth_client.get_project_id()
elif self.orchestrator == 'vcenter':
self.auth_client = VcenterAuth(self.username,
self.password,
self.project_name,
self.inputs
)
self.project_id = self.auth_client.get_project_id()
self.vnc_h = ContrailVncApi(self.vnc_api_h, self.logger)
def setUp(self):
super(VncLibFixture, self).setUp()
if self.connections:
self.logger = self.connections.logger
self.project_name = self.connections.project_name
self.inputs = self.connections.inputs
self.neutron_handle = self.connections.quantum_h
self.vnc_api_h = self.connections.vnc_lib
self.username = self.connections.username
self.password = self.connections.password
self.cfgm_ip = self.inputs.cfgm_ip
self.auth_server_ip = self.inputs.auth_ip
self.auth_client = self.connections.auth
self.project_id = self.connections.project_id
else:
self.logger = self.logger or contrail_logging.getLogger(__name__)
self.vnc_api_h = VncApi(
username=self.username,
password=self.password,
tenant_name=self.project_name,
domain_name=self.domain,
api_server_host=self.cfgm_ip,
api_server_port=self.api_server_port,
auth_host=self.auth_server_ip,
api_server_use_ssl=self.use_ssl,
auth_url=self.authn_url)
if self.orchestrator == 'openstack':
self.auth_client = OpenstackAuth(
self.username,
self.password,
self.project_name,
domain_name=self.domain,
auth_url=self.auth_url,
certfile=self.certfile,
keyfile=self.keyfile,
cacert=self.cacert,
insecure=self.insecure,
logger=self.logger)
elif self.orchestrator == 'vcenter':
self.auth_client = VcenterAuth(self.username,
self.password,
self.project_name,
self.inputs
)
if not self.project_id:
self.project_id = self.vnc_api_h.project_read(
fq_name=[self.domain, self.project_name]).uuid
if self.orch:
self.vnc_h = self.orch.vnc_h
else:
self.vnc_h = ContrailVncApi(self.vnc_api_h, self.logger)
def get_auth_h(self, refresh=False, project_name=None,
username=None, password=None):
project_name = project_name or self.project_name
username = username or self.username
password = password or self.password
attr = '_auth_'+project_name+'_'+username
if not getattr(env, attr, None) or refresh:
if self.inputs.orchestrator == 'openstack':
env[attr] = OpenstackAuth(username, password,
project_name, self.inputs, self.logger)
else:
env[attr] = VcenterAuth(username, password,
project_name, self.inputs)
return env[attr]
class ProjectFixture(fixtures.Fixture):
def __init__(self, connections, auth=None, project_name=None,
username=None, password=None, role='admin',
domain_name=None, uuid=None):
self.inputs = connections.inputs
self.vnc_lib_h = connections.get_vnc_lib_h()
self.vnc_lib_fixture = connections.vnc_lib_fixture
self.logger = connections.logger
self.connections = connections
self.auth = auth
self.project_name = project_name or self.inputs.stack_tenant
self.orch_domain_name = domain_name or self.inputs.stack_domain
if self.orch_domain_name == 'Default':
self.domain_name = 'default-domain'
else:
self.domain_name = self.orch_domain_name
self.domain_id = self.connections.domain_id or 'default'
self.uuid = uuid
self.project_obj = None
self.already_present = False
self.project_fq_name = [self.domain_name, self.project_name]
self.project_username = self.username = username or self.connections.username
self.project_user_password = self.password = password or self.connections.password
self.role = role
self.user_dict = {}
self._create_user_set = {}
self.project_connections = dict()
self.project_inputs = dict()
self.api_server_inspects = self.connections.api_server_inspects
self.verify_is_run = False
if not self.auth:
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.inputs.admin_username,
self.inputs.admin_password,
self.inputs.admin_tenant, self.inputs, self.logger,
domain_name=self.inputs.admin_domain)
elif self.inputs.orchestrator == 'vcenter':
self.auth = VcenterAuth(self.inputs.admin_username,
self.inputs.admin_password,
self.inputs.admin_tenant, self.inputs)
else:
# Kubernetes
# Set no auth for now
self.auth = None
# end __init__
def _create_project(self):
if self.auth:
self.uuid = self.auth.create_project(self.project_name,
self.orch_domain_name)
self.project_obj = self.vnc_lib_fixture.project_read(id=self.uuid)
else:
# Create it in Contrail-api
self.project_obj = self.vnc_lib_fixture.create_project(
self.project_name)
self._populate_attr()
# self.project_obj = self.vnc_lib_h.project_read(id=self.uuid)
self.logger.info('Created Project:%s, ID : %s ' % (self.project_name,
self.uuid))
# end _create_project
def _delete_project(self):
if self.auth:
self.auth.delete_project(self.project_name)
else:
self.vnc_lib_fixture.delete_project(self.project_name)
self.logger.info('Deleted project: %s, ID : %s ' % (self.project_name,
self.uuid))
# end _delete_project
def _populate_attr(self):
if self.project_obj:
self.uuid = self.project_obj.uuid
self.project_name = self.project_obj.name
self.project_fq_name = self.project_obj.get_fq_name()
def setUp(self):
super(ProjectFixture, self).setUp()
self.create()
def read(self):
# Incase of kubernetes, read the project from vnc api
# In other cases, it can be got from self.auth
if self.auth:
self.uuid = self.auth.get_project_id(self.project_name,
self.domain_id)
if self.uuid:
args = {'id':self.uuid}
else:
args = {'fq_name':self.project_fq_name}
try:
self.project_obj = self.vnc_lib_h.project_read(**args)
self._populate_attr()
self.already_present = True
return self.uuid
except NoIdError:
return None
# end read
def create(self):
self.uuid = self.read()
if self.uuid:
self.logger.info(
'Using existing project %s(%s)'%(
self.project_fq_name, self.uuid))
elif self.project_name == self.inputs.stack_tenant:
raise Exception('Project %s not found' % (self.project_name))
else:
self.logger.info('Project %s not found, creating it' % (
self.project_name))
self._create_project()
def get_uuid(self):
return self.uuid
def get_fq_name(self):
return self.project_fq_name
def getObj(self):
return self.project_obj
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
if self.auth:
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=30)
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 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_connections(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
inputs = self.get_inputs(username=username, password=password)
if username not in self.project_connections:
self.project_connections[username] = ContrailConnections(
inputs=inputs,
logger=self.logger,
project_name=self.project_name,
username=username,
password=password,
domain_name=self.orch_domain_name,
scope='project')
return self.project_connections[username]
# end get_project_connections
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 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
for cfgm_ip in self.inputs.cfgm_ips:
api_s_inspect = self.api_server_inspects[cfgm_ip]
cs_project_obj = api_s_inspect.get_cs_project(
self.domain_name,
self.project_name)
if not cs_project_obj:
self.logger.debug('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
for cfgm_ip in self.inputs.cfgm_ips:
api_s_inspect = self.api_server_inspects[cfgm_ip]
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.debug('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, project_name=None, sg_name='default'):
project_name = project_name or self.project_name
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,
'ethertype': 'IPv4'
},
{'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,
'ethertype': 'IPv4'
},
{'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': '::', 'ip_prefix_len': 0}}],
'ethertype': 'IPv6'
},
{'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': '::', 'ip_prefix_len': 0}}],
'ethertype': 'IPv6'
}
]
self.update_sec_group(project_name, sg_name, rule1)
# end set_sec_group_for_allow_all
def update_sec_group(self, project_name, sec_group_name, rules):
def_sec_grp = self.vnc_lib_h.security_group_read(
fq_name=[u'default-domain', project_name, sec_group_name])
try:
old_rules = def_sec_grp.get_security_group_entries(
).get_policy_rule()
except AttributeError:
old_rules = []
self.logger.info(
"Adding rules to the %s security group in Project %s" %
(sec_group_name, project_name))
self.set_sec_group(project_name, sec_group_name, rules)
self.addCleanup(self.set_sec_group, project_name,
sec_group_name, old_rules)
def set_sec_group(self, project_name, sec_group_name, rules):
rule_list = PolicyEntriesType(policy_rule=rules)
project_fq_name = [u'default-domain', project_name]
sg_fq_name = [u'default-domain', project_name, sec_group_name]
project = self.vnc_lib_h.project_read(fq_name=project_fq_name)
def_sec_grp = self.vnc_lib_h.security_group_read(fq_name=sg_fq_name)
def_sec_grp = SecurityGroup(
name=sec_group_name, parent_obj=project, security_group_entries=rule_list)
def_sec_grp.set_security_group_entries(rule_list)
self.vnc_lib_h.security_group_update(def_sec_grp)
@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
# end verify_on_cleanup
def set_user_creds(self, username, password):
'''Set a user,password who is allowed to login to this project
'''
self.project_username = username
self.project_user_password = password
class VncLibFixture(fixtures.Fixture):
''' Wrapper for VncApi
:param domain : default is default-domain
:param project_name : default is admin
:param cfgm_ip : default is 127.0.0.1
:param api_port : default is 8082
:param connections : ContrailConnections object. default is None
:param username : default is admin
:param password : default is contrail123
:param auth_server_ip : default is 127.0.0.1
:param logger : logger object
'''
def __init__(self, *args, **kwargs):
self.username = kwargs.get('username', 'admin')
self.password = kwargs.get('password', 'contrail123')
self.project_name = kwargs.get('project_name', 'admin')
self.domain = kwargs.get('domain', 'default-domain')
self.api_server_port = kwargs.get('api_server_port', '8082')
self.cfgm_ip = kwargs.get('cfgm_ip', '127.0.0.1')
self.auth_server_ip = kwargs.get('auth_server_ip', None)
self.logger = kwargs.get('logger', logging.getLogger(__name__))
self.connections = kwargs.get('connections', None)
self.orchestrator = kwargs.get('orchestrator', 'openstack')
self.vnc_api_h = None
self.auth_client_h = None
self.inputs = kwargs.get('inputs', None)
self.neutron_handle = None
self.auth_url = os.getenv('OS_AUTH_URL')
if self.auth_server_ip:
self.auth_url = 'http://' + self.auth_server_ip + ':5000/v2.0'
# end __init__
def setUp(self):
super(VncLibFixture, self).setUp()
if self.connections:
self.logger = self.connections.logger
self.project_name = self.connections.project_name
self.inputs = self.connections.inputs
self.neutron_handle = self.connections.quantum_h
self.vnc_api_h = self.connections.vnc_lib
self.username = self.connections.username
self.password = self.connections.password
self.cfgm_ip = self.inputs.cfgm_ip
self.auth_server_ip = self.inputs.auth_ip
self.project_id = self.connections.project_id
self.auth_url = 'http://' + self.inputs.auth_ip + ':5000/v2.0'
else:
self.vnc_api_h = VncApi(
username=self.username,
password=self.password,
tenant_name=self.project_name,
api_server_host=self.cfgm_ip,
api_server_port=self.api_server_port,
auth_host=self.auth_server_ip)
if self.orchestrator == 'openstack':
self.auth_client = OpenstackAuth(
self.username,
self.password,
self.project_name,
auth_url=self.auth_url,
logger=self.logger)
self.project_id = self.auth_client.get_project_id()
elif self.orchestrator == 'vcenter':
self.auth_client = VcenterAuth(self.username,
self.password,
self.project_name,
self.inputs
)
self.project_id = self.auth_client.get_project_id()
# end setUp
def cleanUp(self):
super(VncLibFixture, self).cleanUp()
def get_handle(self):
return self.vnc_api_h
# end get_handle
def get_neutron_handle(self):
if self.neutron_handle:
return self.neutron_handle
else:
self.orch = OpenstackOrchestrator(username=self.username,
password=self.password,
project_id=self.project_id,
project_name=self.project_name,
auth_server_ip=self.auth_server_ip,
vnclib=self.vnc_api_h,
logger=self.logger)
self.neutron_handle = self.orch.get_network_handler()
# end get_neutron_handle
def get_forwarding_mode(self, vn_fq_name):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = vnc_lib.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0] and
vni_record['fq_name'][1] == vn_fq_name.split(":")[1] and
vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties()
if vni_obj_properties:
fw_mode = vni_obj_properties.get_forwarding_mode()
else:
fw_mode = None
return fw_mode
# end get_forwarding_mode
def get_vn_subnet_dhcp_flag(self, vn_fq_name):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = vnc_lib.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0] and
vni_record['fq_name'][1] == vn_fq_name.split(":")[1] and
vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
subnets = vni_obj.network_ipam_refs[0]['attr']
ipam = subnets.get_ipam_subnets()
enable_dhcp = ipam[0].get_enable_dhcp()
return enable_dhcp
# get_vn_subnet_dhcp_flag
def set_rpf_mode(self, vn_fq_name, mode):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = self.vnc_api_h.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0] and
vni_record['fq_name'][1] == vn_fq_name.split(":")[1] and
vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties() or VirtualNetworkType()
vni_obj_properties.set_rpf(mode)
vni_obj.set_virtual_network_properties(vni_obj_properties)
vnc_lib.virtual_network_update(vni_obj)
# end set_rpf_mode
def id_to_fq_name(self, id):
return self.vnc_api_h.id_to_fq_name(id)
def set_vxlan_mode(self, vxlan_mode='automatic'):
''' one of automatic or configured
'''
fq_name = [ 'default-global-system-config',
'default-global-vrouter-config']
vrouter_config = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
vrouter_config.set_vxlan_network_identifier_mode(vxlan_mode)
self.vnc_api_h.global_vrouter_config_update(vrouter_config)
def get_vxlan_mode(self):
fq_name = [ 'default-global-system-config',
'default-global-vrouter-config']
vrouter_config = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
return vrouter_config.get_vxlan_network_identifier_mode()
# end
def get_global_asn(self, gsc_id=None):
gsc_id = gsc_id or self.vnc_api_h.get_default_global_system_config_id()
gsc_obj = self.vnc_api_h.global_system_config_read(id=gsc_id)
return gsc_obj.get_autonomous_system()
# end get_global_asn
def set_global_asn(self, asn, gsc_id=None):
gsc_id = gsc_id or self.vnc_api_h.get_default_global_system_config_id()
gsc_obj = self.vnc_api_h.global_system_config_read(id=gsc_id)
gsc_obj.set_autonomous_system(int(asn))
self.vnc_api_h.global_system_config_update(gsc_obj)
class VncLibFixture(fixtures.Fixture):
''' Wrapper for VncApi
:param domain : default is default-domain
:param project_name : default is admin
:param cfgm_ip : default is 127.0.0.1
:param api_port : default is 8082
:param connections : ContrailConnections object. default is None
:param username : default is admin
:param password : default is contrail123
:param auth_server_ip : default is 127.0.0.1
:param project_id : defualt is None
:param logger : logger object
'''
def __init__(self, *args, **kwargs):
self.username = os.getenv('OS_USERNAME') or \
kwargs.get('username', 'admin')
self.password = os.getenv('OS_PASSWORD') or \
kwargs.get('password', 'contrail123')
self.project_name = kwargs.get('project_name', 'admin')
self.domain = kwargs.get('domain', 'default-domain')
self.api_server_port = kwargs.get('api_server_port', '8082')
self.cfgm_ip = kwargs.get('cfgm_ip', '127.0.0.1')
self.logger = kwargs.get('logger', None)
self.connections = kwargs.get('connections', None)
self.orchestrator = kwargs.get('orchestrator', 'openstack')
self.vnc_api_h = None
self.inputs = self.connections.inputs if self.connections \
else kwargs.get('inputs', None)
self.neutron_handle = None
self.auth_server_ip = self.inputs.auth_ip if self.inputs else \
kwargs.get('auth_server_ip', '127.0.0.1')
self.auth_url = self.inputs.auth_url if self.inputs else \
os.getenv('OS_AUTH_URL') or \
'http://%s:5000/v2.0'%self.auth_server_ip
self.project_id = kwargs.get('project_id', None)
# end __init__
def setUp(self):
super(VncLibFixture, self).setUp()
if self.connections:
self.logger = self.connections.logger
self.project_name = self.connections.project_name
self.inputs = self.connections.inputs
self.neutron_handle = self.connections.quantum_h
self.vnc_api_h = self.connections.vnc_lib
self.username = self.connections.username
self.password = self.connections.password
self.cfgm_ip = self.inputs.cfgm_ip
self.auth_server_ip = self.inputs.auth_ip
self.project_id = self.connections.project_id
self.auth_url = 'http://' + self.inputs.auth_ip + ':5000/v2.0'
else:
self.logger = self.logger or contrail_logging.getLogger(__name__)
self.vnc_api_h = VncApi(username=self.username,
password=self.password,
tenant_name=self.project_name,
api_server_host=self.cfgm_ip,
api_server_port=self.api_server_port,
auth_host=self.auth_server_ip)
if not self.project_id:
if self.orchestrator == 'openstack':
self.auth_client = OpenstackAuth(self.username,
self.password,
self.project_name,
auth_url=self.auth_url,
logger=self.logger)
self.project_id = self.auth_client.get_project_id()
elif self.orchestrator == 'vcenter':
self.auth_client = VcenterAuth(self.username,
self.password,
self.project_name,
self.inputs)
self.project_id = self.auth_client.get_project_id()
self.vnc_h = ContrailVncApi(self.vnc_api_h, self.logger)
# end setUp
def cleanUp(self):
super(VncLibFixture, self).cleanUp()
def get_handle(self):
return self.vnc_api_h
# end get_handle
def get_neutron_handle(self):
if self.neutron_handle:
return self.neutron_handle
else:
self.orch = OpenstackOrchestrator(
username=self.username,
password=self.password,
project_id=self.project_id,
project_name=self.project_name,
auth_server_ip=self.auth_server_ip,
vnclib=self.vnc_api_h,
logger=self.logger,
inputs=self.inputs)
self.neutron_handle = self.orch.get_network_handler()
return self.neutron_handle
# end get_neutron_handle
def get_project_obj(self):
if self.connections:
project_id = self.connections.project_id
elif self.project_id:
project_id = self.project_id
else:
project_id = self.vnc_api_h.project_read(
fq_name_str='default-domain:default-project').uuid
parent_obj = self.vnc_api_h.project_read(id=project_id)
return parent_obj
# end get_parent_obj
def get_forwarding_mode(self, vn_fq_name):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = vnc_lib.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0]
and vni_record['fq_name'][1] == vn_fq_name.split(":")[1]
and vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties()
if vni_obj_properties:
fw_mode = vni_obj_properties.get_forwarding_mode()
else:
fw_mode = None
return fw_mode
# end get_forwarding_mode
def get_vn_subnet_dhcp_flag(self, vn_fq_name):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = vnc_lib.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0]
and vni_record['fq_name'][1] == vn_fq_name.split(":")[1]
and vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
subnets = vni_obj.network_ipam_refs[0]['attr']
ipam = subnets.get_ipam_subnets()
enable_dhcp = ipam[0].get_enable_dhcp()
return enable_dhcp
# get_vn_subnet_dhcp_flag
def set_rpf_mode(self, vn_fq_name, mode):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = self.vnc_api_h.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0]
and vni_record['fq_name'][1] == vn_fq_name.split(":")[1]
and vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties(
) or VirtualNetworkType()
vni_obj_properties.set_rpf(mode)
vni_obj.set_virtual_network_properties(vni_obj_properties)
vnc_lib.virtual_network_update(vni_obj)
# end set_rpf_mode
def id_to_fq_name(self, id):
return self.vnc_api_h.id_to_fq_name(id)
def set_vxlan_mode(self, vxlan_mode='automatic'):
''' one of automatic or configured
'''
fq_name = [
'default-global-system-config', 'default-global-vrouter-config'
]
vrouter_config = self.vnc_api_h.global_vrouter_config_read(
fq_name=fq_name)
vrouter_config.set_vxlan_network_identifier_mode(vxlan_mode)
self.vnc_api_h.global_vrouter_config_update(vrouter_config)
def get_vxlan_mode(self):
fq_name = [
'default-global-system-config', 'default-global-vrouter-config'
]
vrouter_config = self.vnc_api_h.global_vrouter_config_read(
fq_name=fq_name)
return vrouter_config.get_vxlan_network_identifier_mode()
# end
def get_global_asn(self, gsc_id=None):
gsc_id = gsc_id or self.vnc_api_h.get_default_global_system_config_id()
gsc_obj = self.vnc_api_h.global_system_config_read(id=gsc_id)
return gsc_obj.get_autonomous_system()
# end get_global_asn
def set_global_asn(self, asn, gsc_id=None):
gsc_id = gsc_id or self.vnc_api_h.get_default_global_system_config_id()
gsc_obj = self.vnc_api_h.global_system_config_read(id=gsc_id)
gsc_obj.set_autonomous_system(int(asn))
self.vnc_api_h.global_system_config_update(gsc_obj)
# end set_global_asn
def get_global_forwarding_mode(self):
fq_name = [
'default-global-system-config', 'default-global-vrouter-config'
]
gsc_obj = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
return gsc_obj.get_forwarding_mode()
# end get_global_forwarding_mode
def get_active_forwarding_mode(self, vn_fq_name):
''' Returns l2 or l3 or l2_l3
Returns Vn's forwarding mode if set.
If VN forwarding mode is not set, returns global forwarding mode
If global forwarding mode too is not set, returns 'l2_l3' since this is the default.
"'''
if type(vn_fq_name).__name__ == 'str':
vn_fq_name = vn_fq_name.split(':')
gl_fw_mode = self.get_global_forwarding_mode()
vn_fw_mode = self.get_forwarding_mode(vn_fq_name)
if vn_fw_mode:
return vn_fw_mode
elif gl_fw_mode:
return gl_fw_mode
else:
return 'l2_l3'
#end get_active_forwarding_mode
def set_global_forwarding_mode(self, forwarding_mode):
fq_name = [
'default-global-system-config', 'default-global-vrouter-config'
]
gsc_obj = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
gsc_obj.set_forwarding_mode(forwarding_mode)
self.vnc_api_h.global_vrouter_config_update(gsc_obj)
#end set_global_forwarding_mode
def get_flow_export_rate(self):
fq_name = [
'default-global-system-config', 'default-global-vrouter-config'
]
gv_obj = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
rate = gv_obj.get_flow_export_rate()
if not rate:
# If not set, return 100 , since this is default
return 100
else:
return rate
# end get_flow_export_rate
def set_flow_export_rate(self, value):
'''
Set flow export rate in default global vrouter config
value : Value of flow export rate to be set
'''
fq_name = [
'default-global-system-config', 'default-global-vrouter-config'
]
gv_obj = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
gv_obj.set_flow_export_rate(int(value))
self.vnc_api_h.global_vrouter_config_update(gv_obj)
self.logger.info('Setting flow export rate: %s' % (value))
return True
def __init__(self,
inputs,
logger,
project_name=None,
username=None,
password=None):
self.inputs = inputs
project_name = project_name or self.inputs.project_name
username = username or self.inputs.stack_user
password = password or self.inputs.stack_password
self.username = username
self.password = password
self.project_name = project_name
self.vnc_lib_fixture = VncLibFixture(
username=username,
password=password,
domain=self.inputs.domain_name,
project=project_name,
inputs=self.inputs,
cfgm_ip=self.inputs.cfgm_ip,
api_port=self.inputs.api_server_port)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
self.nova_h = None
self.quantum_h = None
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(username, password, project_name,
self.inputs, logger)
self.project_id = self.auth.get_project_id(self.inputs.domain_name,
project_name)
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=username,
password=password,
project_id=self.project_id,
project_name=project_name,
inputs=inputs,
vnclib=self.vnc_lib,
logger=logger)
self.nova_h = self.orch.nova_h
self.quantum_h = self.orch.quantum_h
else: # vcenter
self.auth = VcenterAuth(username, password, project_name,
self.inputs)
self.orch = VcenterOrchestrator(user=username,
pwd=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=logger)
self.api_server_inspects = {}
self.dnsagent_inspect = {}
self.cn_inspect = {}
self.agent_inspect = {}
self.ops_inspects = {}
self.ds_inspect = {}
self.update_inspect_handles()
class ContrailConnections():
def __init__(self,
inputs,
logger,
project_name=None,
username=None,
password=None):
self.inputs = inputs
project_name = project_name or self.inputs.project_name
username = username or self.inputs.stack_user
password = password or self.inputs.stack_password
self.username = username
self.password = password
self.project_name = project_name
self.vnc_lib_fixture = VncLibFixture(
username=username,
password=password,
domain=self.inputs.domain_name,
project=project_name,
inputs=self.inputs,
cfgm_ip=self.inputs.cfgm_ip,
api_port=self.inputs.api_server_port)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
self.nova_h = None
self.quantum_h = None
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(username, password, project_name,
self.inputs, logger)
self.project_id = self.auth.get_project_id(self.inputs.domain_name,
project_name)
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=username,
password=password,
project_id=self.project_id,
project_name=project_name,
inputs=inputs,
vnclib=self.vnc_lib,
logger=logger)
self.nova_h = self.orch.nova_h
self.quantum_h = self.orch.quantum_h
else: # vcenter
self.auth = VcenterAuth(username, password, project_name,
self.inputs)
self.orch = VcenterOrchestrator(user=username,
pwd=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=logger)
self.api_server_inspects = {}
self.dnsagent_inspect = {}
self.cn_inspect = {}
self.agent_inspect = {}
self.ops_inspects = {}
self.ds_inspect = {}
self.update_inspect_handles()
# end __init__
def update_inspect_handles(self):
self.api_server_inspects.clear()
self.cn_inspect.clear()
self.dnsagent_inspect.clear()
self.agent_inspect.clear()
self.ops_inspects.clear()
self.ds_inspect.clear()
for cfgm_ip in self.inputs.cfgm_ips:
self.api_server_inspects[cfgm_ip] = VNCApiInspect(
cfgm_ip, args=self.inputs, logger=self.inputs.logger)
self.api_server_inspect = VNCApiInspect(cfgm_ip,
args=self.inputs,
logger=self.inputs.logger)
for bgp_ip in self.inputs.bgp_ips:
self.cn_inspect[bgp_ip] = ControlNodeInspect(
bgp_ip, logger=self.inputs.logger)
self.dnsagent_inspect[bgp_ip] = DnsAgentInspect(
bgp_ip, logger=self.inputs.logger)
for compute_ip in self.inputs.compute_ips:
self.agent_inspect[compute_ip] = AgentInspect(
compute_ip, logger=self.inputs.logger)
for collector_ip in self.inputs.collector_ips:
self.ops_inspects[collector_ip] = VerificationOpsSrv(
collector_ip, logger=self.inputs.logger)
self.ops_inspect = VerificationOpsSrv(self.inputs.collector_ip,
logger=self.inputs.logger)
for collector_name in self.inputs.collector_names:
self.ops_inspects[collector_name] = VerificationOpsSrv(
collector_ip, logger=self.inputs.logger)
self.analytics_obj = AnalyticsVerification(self.inputs,
self.api_server_inspect,
self.cn_inspect,
self.agent_inspect,
self.ops_inspects,
logger=self.inputs.logger)
for ds_ip in self.inputs.ds_server_ip:
self.ds_inspect[ds_ip] = VerificationDsSrv(
ds_ip, logger=self.inputs.logger)
self.ds_verification_obj = DiscoveryVerification(
self.inputs,
self.api_server_inspect,
self.cn_inspect,
self.agent_inspect,
self.ops_inspects,
self.ds_inspect,
logger=self.inputs.logger)
# end update_inspect_handles
def setUp(self):
super(ContrailConnections, self).setUp()
pass
# end
def cleanUp(self):
super(ContrailConnections, self).cleanUp()
pass
# end
def set_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config = self.obj.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
current_linklocal = current_config.get_linklocal_services()
except NoIdError as e:
self.inputs.logger.exception(
'No config id found. Creating new one')
current_linklocal = ''
encap_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
conf_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,
encapsulation_priorities=encap_obj)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_encap
def update_vrouter_config_encap(self,
encap1=None,
encap2=None,
encap3=None):
'''Used to change the existing encapsulation priorities to new values'''
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config = self.obj.global_vrouter_config_read(fq_name=[
'default-global-system-config', 'default-global-vrouter-config'
])
current_linklocal = current_config.get_linklocal_services()
except NoIdError as e:
self.inputs.logger.exception(
'No config id found. Creating new one')
current_linklocal = ''
encaps_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
confs_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,
encapsulation_priorities=encaps_obj)
result = self.obj.global_vrouter_config_update(confs_obj)
return result
# end update_vrouter_config_encap
def delete_vrouter_encap(self):
self.obj = self.vnc_lib
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.inputs.logger.info("Config id found.Deleting it")
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
if not self.inputs.config.obj:
# temp workaround,delete default-global-vrouter-config.need to
# review this testcase
self.obj.global_vrouter_config_delete(id=conf_id)
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
return (errmsg)
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
encaps3 = self.inputs.config.obj.encapsulation[2]
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, encaps3)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, None)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, None, None)
except NoIdError:
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
return (errmsg)
# end delete_vrouter_encap
def read_vrouter_config_encap(self):
result = None
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
result = self.inputs.config.obj.encapsulation
except NoIdError:
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
return result
# end read_vrouter_config_encap
def set_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
# Check if already configured
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except Exception:
msg = "No config id found. Configuring new one"
self.inputs.logger.info(msg)
pass
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_evpn
def update_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_update(conf_obj)
return result
# end update_vrouter_config_evpn
def delete_vrouter_config_evpn(self):
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except NoIdError:
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
# end delete_vrouter_config_evpn
def read_vrouter_config_evpn(self):
result = False
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
out = self.obj.global_vrouter_config_read(id=conf_id)
if 'evpn_status' in out.__dict__.keys():
result = out.evpn_status
except NoIdError:
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
return result
# end read_vrouter_config_evpn
def update_vnc_lib_fixture(self):
self.vnc_lib_fixture.cleanUp()
self.vnc_lib_fixture = VncLibFixture(
username=self.username,
password=self.password,
domain=self.inputs.domain_name,
project=self.project_name,
inputs=self.inputs,
cfgm_ip=self.inputs.cfgm_ip,
api_port=self.inputs.api_server_port)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
class VncLibFixture(fixtures.Fixture):
''' Wrapper for VncApi
:param domain : default is default-domain
:param project_name : default is admin
:param cfgm_ip : default is 127.0.0.1
:param api_port : default is 8082
:param connections : ContrailConnections object. default is None
:param username : default is admin
:param password : default is contrail123
:param auth_server_ip : default is 127.0.0.1
:param project_id : defualt is None
:param logger : logger object
'''
def __init__(self, *args, **kwargs):
self.username = os.getenv('OS_USERNAME') or \
kwargs.get('username', 'admin')
self.password = os.getenv('OS_PASSWORD') or \
kwargs.get('password', 'contrail123')
self.project_name = kwargs.get('project_name', 'admin')
self.domain = kwargs.get('domain', 'default-domain')
self.api_server_port = kwargs.get('api_server_port', '8082')
self.logger = kwargs.get('logger', None)
self.connections = kwargs.get('connections', None)
self.orchestrator = kwargs.get('orchestrator', 'openstack')
self.vnc_api_h = None
self.inputs = self.connections.inputs if self.connections \
else kwargs.get('inputs', None)
self.neutron_handle = None
self.cfgm_ip = kwargs.get('cfgm_ip', self.inputs.cfgm_ip if self.inputs else '127.0.0.1')
self.auth_server_ip = self.inputs.auth_ip if self.inputs else \
kwargs.get('auth_server_ip', '127.0.0.1')
self.auth_url = self.inputs.auth_url if self.inputs else \
os.getenv('OS_AUTH_URL') or \
'http://%s:5000/v2.0'%self.auth_server_ip
self.project_id = kwargs.get('project_id', None)
# end __init__
def setUp(self):
super(VncLibFixture, self).setUp()
if self.connections:
self.logger = self.connections.logger
self.project_name = self.connections.project_name
self.inputs = self.connections.inputs
self.neutron_handle = self.connections.quantum_h
self.vnc_api_h = self.connections.vnc_lib
self.username = self.connections.username
self.password = self.connections.password
self.cfgm_ip = self.inputs.cfgm_ip
self.auth_server_ip = self.inputs.auth_ip
self.project_id = self.connections.project_id
self.auth_url = 'http://' + self.inputs.auth_ip + ':5000/v2.0'
else:
self.logger = self.logger or contrail_logging.getLogger(__name__)
self.vnc_api_h = VncApi(
username=self.username,
password=self.password,
tenant_name=self.project_name,
api_server_host=self.cfgm_ip,
api_server_port=self.api_server_port,
auth_host=self.auth_server_ip)
if not self.project_id:
if self.orchestrator == 'openstack':
self.auth_client = OpenstackAuth(
self.username,
self.password,
self.project_name,
auth_url=self.auth_url,
logger=self.logger)
self.project_id = self.auth_client.get_project_id()
elif self.orchestrator == 'vcenter':
self.auth_client = VcenterAuth(self.username,
self.password,
self.project_name,
self.inputs
)
self.project_id = self.auth_client.get_project_id()
self.vnc_h = ContrailVncApi(self.vnc_api_h, self.logger)
# end setUp
def cleanUp(self):
super(VncLibFixture, self).cleanUp()
def get_handle(self):
return self.vnc_api_h
# end get_handle
def get_neutron_handle(self):
if self.neutron_handle:
return self.neutron_handle
else:
self.orch = OpenstackOrchestrator(username=self.username,
password=self.password,
project_id=self.project_id,
project_name=self.project_name,
auth_server_ip=self.auth_server_ip,
vnclib=self.vnc_api_h,
logger=self.logger, inputs=self.inputs)
self.neutron_handle = self.orch.get_network_handler()
return self.neutron_handle
# end get_neutron_handle
def get_project_obj(self):
if self.connections:
project_id = self.connections.project_id
elif self.project_id:
project_id = self.project_id
else:
project_id = self.vnc_api_h.project_read(
fq_name_str='default-domain:default-project').uuid
parent_obj = self.vnc_api_h.project_read(id=project_id)
return parent_obj
# end get_parent_obj
def get_forwarding_mode(self, vn_fq_name):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = vnc_lib.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0] and
vni_record['fq_name'][1] == vn_fq_name.split(":")[1] and
vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties()
if vni_obj_properties:
fw_mode = vni_obj_properties.get_forwarding_mode()
else:
fw_mode = None
return fw_mode
# end get_forwarding_mode
def get_vn_subnet_dhcp_flag(self, vn_fq_name):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = vnc_lib.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0] and
vni_record['fq_name'][1] == vn_fq_name.split(":")[1] and
vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
subnets = vni_obj.network_ipam_refs[0]['attr']
ipam = subnets.get_ipam_subnets()
enable_dhcp = ipam[0].get_enable_dhcp()
return enable_dhcp
# get_vn_subnet_dhcp_flag
def set_rpf_mode(self, vn_fq_name, mode):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = self.vnc_api_h.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0] and
vni_record['fq_name'][1] == vn_fq_name.split(":")[1] and
vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties() or VirtualNetworkType()
vni_obj_properties.set_rpf(mode)
vni_obj.set_virtual_network_properties(vni_obj_properties)
vnc_lib.virtual_network_update(vni_obj)
# end set_rpf_mode
def id_to_fq_name(self, id):
return self.vnc_api_h.id_to_fq_name(id)
def set_vxlan_mode(self, vxlan_mode='automatic'):
''' one of automatic or configured
'''
fq_name = [ 'default-global-system-config',
'default-global-vrouter-config']
vrouter_config = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
vrouter_config.set_vxlan_network_identifier_mode(vxlan_mode)
self.vnc_api_h.global_vrouter_config_update(vrouter_config)
def get_vxlan_mode(self):
fq_name = [ 'default-global-system-config',
'default-global-vrouter-config']
vrouter_config = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
return vrouter_config.get_vxlan_network_identifier_mode()
# end
def get_global_asn(self, gsc_id=None):
gsc_id = gsc_id or self.vnc_api_h.get_default_global_system_config_id()
gsc_obj = self.vnc_api_h.global_system_config_read(id=gsc_id)
return gsc_obj.get_autonomous_system()
# end get_global_asn
def set_global_asn(self, asn, gsc_id=None):
gsc_id = gsc_id or self.vnc_api_h.get_default_global_system_config_id()
gsc_obj = self.vnc_api_h.global_system_config_read(id=gsc_id)
gsc_obj.set_autonomous_system(int(asn))
self.vnc_api_h.global_system_config_update(gsc_obj)
# end set_global_asn
def get_global_forwarding_mode(self):
fq_name = [ 'default-global-system-config',
'default-global-vrouter-config']
gsc_obj = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
return gsc_obj.get_forwarding_mode()
# end get_global_forwarding_mode
def get_active_forwarding_mode(self,vn_fq_name):
''' Returns l2 or l3 or l2_l3
Returns Vn's forwarding mode if set.
If VN forwarding mode is not set, returns global forwarding mode
If global forwarding mode too is not set, returns 'l2_l3' since this is the default.
"'''
if type(vn_fq_name).__name__ == 'str':
vn_fq_name = vn_fq_name.split(':')
gl_fw_mode = self.get_global_forwarding_mode()
vn_fw_mode = self.get_forwarding_mode(vn_fq_name)
if vn_fw_mode:
return vn_fw_mode
elif gl_fw_mode:
return gl_fw_mode
else:
return 'l2_l3'
#end get_active_forwarding_mode
def set_global_forwarding_mode(self,forwarding_mode):
fq_name = [ 'default-global-system-config',
'default-global-vrouter-config']
gsc_obj = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
gsc_obj.set_forwarding_mode(forwarding_mode)
self.vnc_api_h.global_vrouter_config_update(gsc_obj)
#end set_global_forwarding_mode
def get_flow_export_rate(self):
fq_name = [ 'default-global-system-config',
'default-global-vrouter-config']
gv_obj = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
rate = gv_obj.get_flow_export_rate()
if not rate:
# If not set, return 100 , since this is default
return 100
else:
return rate
# end get_flow_export_rate
def set_flow_export_rate(self, value):
'''
Set flow export rate in default global vrouter config
value : Value of flow export rate to be set
'''
fq_name = [ 'default-global-system-config',
'default-global-vrouter-config']
gv_obj = self.vnc_api_h.global_vrouter_config_read(fq_name=fq_name)
gv_obj.set_flow_export_rate(int(value))
self.vnc_api_h.global_vrouter_config_update(gv_obj)
self.logger.info('Setting flow export rate: %s' % (value))
return True
class ProjectFixture(fixtures.Fixture):
def __init__(self, vnc_lib_h, connections, auth=None, project_name=None,
username=None, password=None, role='admin', scale= False):
self.inputs = connections.inputs
if not project_name:
project_name = self.inputs.stack_tenant
self.vnc_lib_h = vnc_lib_h
self.connections = connections
self.auth = auth
self.project_name = project_name
self.project_obj = None
self.domain_name = 'default-domain'
self.already_present = False
self.logger = connections.inputs.logger
self.project_fq_name = [self.domain_name, self.project_name]
self.username = username
self.password = password
self.role = role
self.user_dict = {}
self._create_user_set = {}
self.project_connections = None
self.api_server_inspects = self.connections.api_server_inspects
self.verify_is_run = False
self.scale = scale
if not self.auth:
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.inputs.stack_user,
self.inputs.stack_password,
self.inputs.project_name, self.inputs, self.logger)
else: # vcenter
self.auth = VcenterAuth(self.inputs.stack_user,
self.inputs.stack_password,
self.inputs.project_name, self.inputs)
# 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
self.logger.info('Proceed with creation of new project.')
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()
if self.scale:
self._create_project()
else:
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 getObj(self):
return self.project_obj
def cleanUp(self):
super(ProjectFixture, self).cleanUp()
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:
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 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_connections(self, username=None, password=None):
if not username:
username = self.username or self.inputs.stack_user
if not password:
password = self.password or self.inputs.stack_password
if not self.project_connections:
self.project_connections = ContrailConnections(
inputs=self.inputs,
logger=self.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
for api_s_inspect in self.api_server_inspects.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
for api_s_inspect in self.api_server_inspects.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, project_name, sg_name):
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(project_name, sg_name, rule1)
# end set_sec_group_for_allow_all
def update_sec_group(self, project_name, sec_group_name, rules):
def_sec_grp = self.vnc_lib_h.security_group_read(
fq_name=[u'default-domain', project_name, sec_group_name])
try:
old_rules = def_sec_grp.get_security_group_entries(
).get_policy_rule()
except AttributeError:
old_rules = []
self.logger.info(
"Adding rules to the %s security group in Project %s" %
(sec_group_name, project_name))
self.set_sec_group(project_name, sec_group_name, rules)
self.addCleanup(self.set_sec_group, project_name,
sec_group_name, old_rules)
def set_sec_group(self, project_name, sec_group_name, rules):
rule_list = PolicyEntriesType(policy_rule=rules)
project_fq_name = [u'default-domain', project_name]
sg_fq_name = [u'default-domain', project_name, sec_group_name]
project = self.vnc_lib_h.project_read(fq_name=project_fq_name)
def_sec_grp = self.vnc_lib_h.security_group_read(fq_name=sg_fq_name)
def_sec_grp = SecurityGroup(
name=sec_group_name, parent_obj=project, security_group_entries=rule_list)
def_sec_grp.set_security_group_entries(rule_list)
self.vnc_lib_h.security_group_update(def_sec_grp)
@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
class ContrailConnections():
def __init__(self, inputs,logger,
project_name=None,
username=None,
password=None):
self.inputs = inputs
project_name = project_name or self.inputs.project_name
username = username or self.inputs.stack_user
password = password or self.inputs.stack_password
self.username = username
self.password = password
self.project_name = project_name
self.vnc_lib_fixture = VncLibFixture(
username=username, password=password,
domain=self.inputs.domain_name, project=project_name,
inputs=self.inputs, cfgm_ip=self.inputs.cfgm_ip,
api_port=self.inputs.api_server_port)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
self.nova_h = None
self.quantum_h = None
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(username, password, project_name, self.inputs, logger)
self.project_id = self.auth.get_project_id(self.inputs.domain_name, project_name)
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=username, password=password,
project_id=self.project_id, project_name=project_name,
inputs=inputs, vnclib=self.vnc_lib, logger=logger)
self.nova_h = self.orch.nova_h
self.quantum_h = self.orch.quantum_h
else: # vcenter
self.auth = VcenterAuth(username, password, project_name, self.inputs)
self.orch = VcenterOrchestrator(user=username, pwd=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=logger)
self.api_server_inspects = {}
self.dnsagent_inspect = {}
self.cn_inspect = {}
self.agent_inspect = {}
self.ops_inspects = {}
self.ds_inspect = {}
self.update_inspect_handles()
# end __init__
def update_inspect_handles(self):
self.api_server_inspects.clear()
self.cn_inspect.clear()
self.dnsagent_inspect.clear()
self.agent_inspect.clear()
self.ops_inspects.clear()
self.ds_inspect.clear()
for cfgm_ip in self.inputs.cfgm_ips:
self.api_server_inspects[cfgm_ip] = VNCApiInspect(cfgm_ip,
args=self.inputs, logger=self.inputs.logger)
self.api_server_inspect = VNCApiInspect(cfgm_ip,
args=self.inputs, logger=self.inputs.logger)
for bgp_ip in self.inputs.bgp_ips:
self.cn_inspect[bgp_ip] = ControlNodeInspect(bgp_ip,
logger=self.inputs.logger)
self.dnsagent_inspect[bgp_ip] = DnsAgentInspect(bgp_ip,
logger=self.inputs.logger)
for compute_ip in self.inputs.compute_ips:
self.agent_inspect[compute_ip] = AgentInspect(compute_ip,
logger=self.inputs.logger)
for collector_ip in self.inputs.collector_ips:
self.ops_inspects[collector_ip] = VerificationOpsSrv(collector_ip,
logger=self.inputs.logger)
self.ops_inspect = VerificationOpsSrv(self.inputs.collector_ip,
logger=self.inputs.logger)
for collector_name in self.inputs.collector_names:
self.ops_inspects[collector_name] = VerificationOpsSrv(
collector_ip,
logger=self.inputs.logger)
self.analytics_obj = AnalyticsVerification(
self.inputs, self.api_server_inspect, self.cn_inspect, self.agent_inspect, self.ops_inspects, logger=self.inputs.logger)
for ds_ip in self.inputs.ds_server_ip:
self.ds_inspect[ds_ip] = VerificationDsSrv(
ds_ip, logger=self.inputs.logger)
self.ds_verification_obj = DiscoveryVerification(
self.inputs, self.api_server_inspect, self.cn_inspect, self.agent_inspect, self.ops_inspects, self.ds_inspect, logger=self.inputs.logger)
# end update_inspect_handles
def setUp(self):
super(ContrailConnections, self).setUp()
pass
# end
def cleanUp(self):
super(ContrailConnections, self).cleanUp()
pass
# end
def set_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config=self.obj.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
current_linklocal=current_config.get_linklocal_services()
except NoIdError as e:
self.inputs.logger.exception('No config id found. Creating new one')
current_linklocal=''
encap_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
conf_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,encapsulation_priorities=encap_obj)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_encap
def update_vrouter_config_encap(self, encap1=None, encap2=None, encap3=None):
'''Used to change the existing encapsulation priorities to new values'''
self.obj = self.vnc_lib
try:
# Reading Existing config
current_config=self.obj.global_vrouter_config_read(
fq_name=['default-global-system-config',
'default-global-vrouter-config'])
current_linklocal=current_config.get_linklocal_services()
except NoIdError as e:
self.inputs.logger.exception('No config id found. Creating new one')
current_linklocal=''
encaps_obj = EncapsulationPrioritiesType(
encapsulation=[encap1, encap2, encap3])
confs_obj = GlobalVrouterConfig(linklocal_services=current_linklocal,
encapsulation_priorities=encaps_obj)
result = self.obj.global_vrouter_config_update(confs_obj)
return result
# end update_vrouter_config_encap
def delete_vrouter_encap(self):
self.obj = self.vnc_lib
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.inputs.logger.info("Config id found.Deleting it")
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
if not self.inputs.config.obj:
# temp workaround,delete default-global-vrouter-config.need to
# review this testcase
self.obj.global_vrouter_config_delete(id=conf_id)
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
return (errmsg)
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
try:
encaps1 = self.inputs.config.obj.encapsulation[0]
encaps2 = self.inputs.config.obj.encapsulation[1]
encaps3 = self.inputs.config.obj.encapsulation[2]
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, encaps3)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, encaps2, None)
except IndexError:
self.obj.global_vrouter_config_delete(id=conf_id)
return (encaps1, None, None)
except NoIdError:
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
return (errmsg)
# end delete_vrouter_encap
def read_vrouter_config_encap(self):
result = None
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
config_parameters = self.obj.global_vrouter_config_read(id=conf_id)
self.inputs.config.obj = config_parameters.get_encapsulation_priorities(
)
result = self.inputs.config.obj.encapsulation
except NoIdError:
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
return result
# end read_vrouter_config_encap
def set_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
# Check if already configured
try:
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except Exception:
msg = "No config id found. Configuring new one"
self.inputs.logger.info(msg)
pass
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_create(conf_obj)
return result
# end set_vrouter_config_evpn
def update_vrouter_config_evpn(self, evpn_status=True):
self.obj = self.vnc_lib
if evpn_status == True:
conf_obj = GlobalVrouterConfig(evpn_status=True)
else:
conf_obj = GlobalVrouterConfig(evpn_status=False)
result = self.obj.global_vrouter_config_update(conf_obj)
return result
# end update_vrouter_config_evpn
def delete_vrouter_config_evpn(self):
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
self.obj.global_vrouter_config_delete(id=conf_id)
except NoIdError:
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
# end delete_vrouter_config_evpn
def read_vrouter_config_evpn(self):
result = False
try:
self.obj = self.vnc_lib
conf_id = self.obj.get_default_global_vrouter_config_id()
out = self.obj.global_vrouter_config_read(id=conf_id)
if 'evpn_status' in out.__dict__.keys():
result = out.evpn_status
except NoIdError:
errmsg = "No config id found"
self.inputs.logger.info(errmsg)
return result
# end read_vrouter_config_evpn
def update_vnc_lib_fixture(self):
self.vnc_lib_fixture.cleanUp()
self.vnc_lib_fixture = VncLibFixture(
username=self.username, password=self.password,
domain=self.inputs.domain_name, project=self.project_name,
inputs=self.inputs, cfgm_ip=self.inputs.cfgm_ip,
api_port=self.inputs.api_server_port)
self.vnc_lib_fixture.setUp()
self.vnc_lib = self.vnc_lib_fixture.get_handle()
class ProjectFixture(fixtures.Fixture):
def __init__(self,
vnc_lib_h,
connections,
auth=None,
project_name=None,
username=None,
password=None,
role='admin',
domain_name=None,
uuid=None):
self.inputs = connections.inputs
self.vnc_lib_h = connections.get_vnc_lib_h()
self.logger = connections.logger
self.connections = connections
self.auth = auth
self.project_name = project_name or self.inputs.stack_tenant
self.domain_name = domain_name or 'default-domain'
self.uuid = uuid
self.project_obj = None
self.already_present = False
self.project_fq_name = [self.domain_name, self.project_name]
self.username = username
self.password = password
self.role = role
self.user_dict = {}
self._create_user_set = {}
self.project_connections = None
self.api_server_inspects = self.connections.api_server_inspects
self.verify_is_run = False
if not self.auth:
if self.inputs.orchestrator == 'openstack':
self.auth = OpenstackAuth(self.inputs.stack_user,
self.inputs.stack_password,
self.inputs.project_name,
self.inputs, self.logger)
else: # vcenter
self.auth = VcenterAuth(self.inputs.stack_user,
self.inputs.stack_password,
self.inputs.project_name, self.inputs)
self.project_username = None
self.project_user_password = None
# end __init__
def read(self):
if self.uuid:
self.project_obj = self.vnc_lib_h.project_read(id=self.uuid)
self.project_name = self.project_obj.name
self.project_fq_name = self.project_obj.get_fq_name()
self.already_present = True
def _create_project(self):
self.uuid = self.auth.create_project(self.project_name)
self.project_obj = self.vnc_lib_h.project_read(id=self.uuid)
self.logger.info('Created Project:%s, ID : %s ' %
(self.project_name, self.uuid))
# end _create_project
def _delete_project(self):
self.auth.delete_project(self.project_name)
print "In project delete, logger is %s" % (self.logger)
print "%s" % (vars(self.logger))
self.logger.info('Deleted project: %s, ID : %s ' %
(self.project_name, self.uuid))
# end _delete_project
def setUp(self):
super(ProjectFixture, self).setUp()
self.create()
def create(self):
self.uuid = self.uuid or self.auth.get_project_id(self.project_name)
if self.uuid:
self.read()
self.logger.info('Using existing project %s(%s)' %
(self.project_fq_name, self.uuid))
elif self.project_name == self.inputs.stack_tenant:
raise Exception('Project %s not found' % (self.project_name))
else:
self.logger.info('Project %s not found, creating it' %
(self.project_name))
self._create_project()
# time.sleep(2)
def get_uuid(self):
return self.uuid
def get_fq_name(self):
return self.project_fq_name
def getObj(self):
return self.project_obj
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=30)
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 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_connections(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 not self.project_connections:
self.project_connections = ContrailConnections(
inputs=self.inputs,
logger=self.logger,
project_name=self.project_name,
username=username,
password=password,
domain_name=self.domain_name)
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
for cfgm_ip in self.inputs.cfgm_ips:
api_s_inspect = self.api_server_inspects[cfgm_ip]
cs_project_obj = api_s_inspect.get_cs_project(
self.domain_name, self.project_name)
if not cs_project_obj:
self.logger.debug('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
for cfgm_ip in self.inputs.cfgm_ips:
api_s_inspect = self.api_server_inspects[cfgm_ip]
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.debug('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,
project_name=None,
sg_name='default'):
project_name = project_name or self.project_name
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(project_name, sg_name, rule1)
# end set_sec_group_for_allow_all
def update_sec_group(self, project_name, sec_group_name, rules):
def_sec_grp = self.vnc_lib_h.security_group_read(
fq_name=[u'default-domain', project_name, sec_group_name])
try:
old_rules = def_sec_grp.get_security_group_entries(
).get_policy_rule()
except AttributeError:
old_rules = []
self.logger.info(
"Adding rules to the %s security group in Project %s" %
(sec_group_name, project_name))
self.set_sec_group(project_name, sec_group_name, rules)
self.addCleanup(self.set_sec_group, project_name, sec_group_name,
old_rules)
def set_sec_group(self, project_name, sec_group_name, rules):
rule_list = PolicyEntriesType(policy_rule=rules)
project_fq_name = [u'default-domain', project_name]
sg_fq_name = [u'default-domain', project_name, sec_group_name]
project = self.vnc_lib_h.project_read(fq_name=project_fq_name)
def_sec_grp = self.vnc_lib_h.security_group_read(fq_name=sg_fq_name)
def_sec_grp = SecurityGroup(name=sec_group_name,
parent_obj=project,
security_group_entries=rule_list)
def_sec_grp.set_security_group_entries(rule_list)
self.vnc_lib_h.security_group_update(def_sec_grp)
@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
# end verify_on_cleanup
def set_user_creds(self, username, password):
'''Set a user,password who is allowed to login to this project
'''
self.project_username = username
self.project_user_password = password
class VncLibFixture(fixtures.Fixture):
''' Wrapper for VncApi
:param domain : default is default-domain
:param project_name : default is admin
:param cfgm_ip : default is 127.0.0.1
:param api_port : default is 8082
:param connections : ContrailConnections object. default is None
:param username : default is admin
:param password : default is contrail123
:param auth_server_ip : default is 127.0.0.1
:param logger : logger object
'''
def __init__(self, *args, **kwargs):
self.username = os.getenv('OS_USERNAME') or \
kwargs.get('username', 'admin')
self.password = os.getenv('OS_PASSWORD') or \
kwargs.get('password', 'contrail123')
self.project_name = kwargs.get('project_name', 'admin')
self.domain = kwargs.get('domain', 'default-domain')
self.api_server_port = kwargs.get('api_server_port', '8082')
self.cfgm_ip = kwargs.get('cfgm_ip', '127.0.0.1')
self.auth_server_ip = kwargs.get('auth_server_ip', '127.0.0.1')
self.logger = kwargs.get('logger', logging.getLogger(__name__))
self.connections = kwargs.get('connections', None)
self.orchestrator = kwargs.get('orchestrator', 'openstack')
self.vnc_api_h = None
self.auth_client_h = None
self.inputs = kwargs.get('inputs', None)
self.neutron_handle = None
self.auth_url = os.getenv('OS_AUTH_URL')
if self.auth_server_ip:
self.auth_url = 'http://' + self.auth_server_ip + ':5000/v2.0'
# end __init__
def setUp(self):
super(VncLibFixture, self).setUp()
if self.connections:
self.logger = self.connections.logger
self.project_name = self.connections.project_name
self.inputs = self.connections.inputs
self.neutron_handle = self.connections.quantum_h
self.vnc_api_h = self.connections.vnc_lib
self.username = self.connections.username
self.password = self.connections.password
self.cfgm_ip = self.inputs.cfgm_ip
self.auth_server_ip = self.inputs.auth_ip
self.project_id = self.connections.project_id
self.auth_url = 'http://' + self.inputs.auth_ip + ':5000/v2.0'
else:
self.vnc_api_h = VncApi(username=self.username,
password=self.password,
tenant_name=self.project_name,
api_server_host=self.cfgm_ip,
api_server_port=self.api_server_port,
auth_host=self.auth_server_ip)
if self.orchestrator == 'openstack':
self.auth_client = OpenstackAuth(self.username,
self.password,
self.project_name,
auth_url=self.auth_url,
logger=self.logger)
self.project_id = self.auth_client.get_project_id()
elif self.orchestrator == 'vcenter':
self.auth_client = VcenterAuth(self.username, self.password,
self.project_name, self.inputs)
self.project_id = self.auth_client.get_project_id()
# end setUp
def cleanUp(self):
super(VncLibFixture, self).cleanUp()
def get_handle(self):
return self.vnc_api_h
# end get_handle
def get_neutron_handle(self):
if self.neutron_handle:
return self.neutron_handle
else:
self.orch = OpenstackOrchestrator(
username=self.username,
password=self.password,
project_id=self.project_id,
project_name=self.project_name,
auth_server_ip=self.auth_server_ip,
vnclib=self.vnc_api_h,
logger=self.logger,
inputs=None)
self.neutron_handle = self.orch.get_network_handler()
return self.neutron_handle
# end get_neutron_handle
def get_forwarding_mode(self, vn_fq_name):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = vnc_lib.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0]
and vni_record['fq_name'][1] == vn_fq_name.split(":")[1]
and vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties()
if vni_obj_properties:
fw_mode = vni_obj_properties.get_forwarding_mode()
else:
fw_mode = None
return fw_mode
# end get_forwarding_mode
def get_vn_subnet_dhcp_flag(self, vn_fq_name):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = vnc_lib.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0]
and vni_record['fq_name'][1] == vn_fq_name.split(":")[1]
and vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
subnets = vni_obj.network_ipam_refs[0]['attr']
ipam = subnets.get_ipam_subnets()
enable_dhcp = ipam[0].get_enable_dhcp()
return enable_dhcp
# get_vn_subnet_dhcp_flag
def set_rpf_mode(self, vn_fq_name, mode):
vnc_lib = self.vnc_api_h
# Figure out VN
vni_list = self.vnc_api_h.virtual_networks_list(
parent_id=self.project_id)['virtual-networks']
for vni_record in vni_list:
if (vni_record['fq_name'][0] == vn_fq_name.split(":")[0]
and vni_record['fq_name'][1] == vn_fq_name.split(":")[1]
and vni_record['fq_name'][2] == vn_fq_name.split(":")[2]):
vni_obj = vnc_lib.virtual_network_read(id=vni_record['uuid'])
vni_obj_properties = vni_obj.get_virtual_network_properties(
) or VirtualNetworkType()
vni_obj_properties.set_rpf(mode)
vni_obj.set_virtual_network_properties(vni_obj_properties)
vnc_lib.virtual_network_update(vni_obj)
# end set_rpf_mode
def id_to_fq_name(self, id):
return self.vnc_api_h.id_to_fq_name(id)
def set_vxlan_mode(self, vxlan_mode='automatic'):
''' one of automatic or configured
'''
fq_name = [
'default-global-system-config', 'default-global-vrouter-config'
]
vrouter_config = self.vnc_api_h.global_vrouter_config_read(
fq_name=fq_name)
vrouter_config.set_vxlan_network_identifier_mode(vxlan_mode)
self.vnc_api_h.global_vrouter_config_update(vrouter_config)
def get_vxlan_mode(self):
fq_name = [
'default-global-system-config', 'default-global-vrouter-config'
]
vrouter_config = self.vnc_api_h.global_vrouter_config_read(
fq_name=fq_name)
return vrouter_config.get_vxlan_network_identifier_mode()
# end
def get_global_asn(self, gsc_id=None):
gsc_id = gsc_id or self.vnc_api_h.get_default_global_system_config_id()
gsc_obj = self.vnc_api_h.global_system_config_read(id=gsc_id)
return gsc_obj.get_autonomous_system()
# end get_global_asn
def set_global_asn(self, asn, gsc_id=None):
gsc_id = gsc_id or self.vnc_api_h.get_default_global_system_config_id()
gsc_obj = self.vnc_api_h.global_system_config_read(id=gsc_id)
gsc_obj.set_autonomous_system(int(asn))
self.vnc_api_h.global_system_config_update(gsc_obj)
