def create(self, name):
domain = self.vnc_handle.domain_read(fq_name=['default-domain'])
obj = vnc_api.Project(name=name, parent_obj=domain)
try:
self.vnc_handle.project_create(obj)
except:
print "ERROR: Failed to create the project {}".format(name)
def _ksv3_sync_project_to_vnc(self, id=None, name=None):
self._get_keystone_conn()
self._get_vnc_conn()
if id:
ks_project = \
self._ks_project_get(id=id.replace('-', ''))
display_name = ks_project['name']
project_id = id
elif name:
ks_project = \
self._ks_project_get(name=name)
project_id = ks_project['id']
display_name = name
domain_uuid = self._ksv3_domain_id_to_uuid(ks_project['domain_id'])
dom_obj = self._vnc_lib.domain_read(id=domain_uuid)
# if earlier project exists with same name but diff id,
# create with uniqified fq_name
fq_name = dom_obj.get_fq_name() + [display_name]
try:
old_id = self._vnc_lib.fq_name_to_id('project', fq_name)
project_name = '%s-%s' % (display_name, str(uuid.uuid4()))
except vnc_api.NoIdError:
project_name = display_name
proj_obj = vnc_api.Project(project_name, parent_obj=dom_obj)
proj_obj.uuid = project_id
self._vnc_lib.project_create(proj_obj)
def _create_vn_ri_vmi(self, obj_count=1):
vn_objs = []
ipam_objs = []
ri_objs = []
vmi_objs = []
for i in range(obj_count):
vn_obj = vnc_api.VirtualNetwork('%s-vn-%s' % (self.id(), i))
ipam_obj = vnc_api.NetworkIpam('%s-ipam-%s' % (self.id(), i))
vn_obj.add_network_ipam(ipam_obj, vnc_api.VnSubnetsType())
self._vnc_lib.network_ipam_create(ipam_obj)
ipam_objs.append(ipam_obj)
self._vnc_lib.virtual_network_create(vn_obj)
vn_objs.append(vn_obj)
ri_obj = vnc_api.RoutingInstance('%s-ri-%s' % (self.id(), i),
parent_obj=vn_obj)
self._vnc_lib.routing_instance_create(ri_obj)
ri_objs.append(ri_obj)
vmi_obj = vnc_api.VirtualMachineInterface(
'%s-vmi-%s' % (self.id(), i), parent_obj=vnc_api.Project())
vmi_obj.add_virtual_network(vn_obj)
self._vnc_lib.virtual_machine_interface_create(vmi_obj)
vmi_objs.append(vmi_obj)
return vn_objs, ipam_objs, ri_objs, vmi_objs
def test_duplicate_name(self):
proj_obj = vnc_api.Project('project-%s' % self.id())
self._vnc_lib.project_create(proj_obj)
for res_type in [
'network', 'subnet', 'security_group', 'port', 'router'
]:
# create a resource
res_name = '%s-%s' % (res_type, self.id())
res_q = self._create_resource_with_fallback(
res_type, proj_obj.uuid, extra_res_fields={'name': res_name})
self.assertThat(res_q['name'], Equals(res_name))
# create another resource
res_q = self._create_resource_with_fallback(
res_type, proj_obj.uuid, extra_res_fields={'name': res_name})
self.assertThat(res_q['name'], Equals(res_name))
if res_type != 'subnet':
self.assertThat(res_q['fq_name'][-1],
Not(Equals(res_q['name'])))
# list by filter of new name
res_list = self.list_resource(res_type,
proj_uuid=proj_obj.uuid,
req_filters={'name': res_name})
self.assertThat(len(res_list), Equals(2))
def test_dup_domain(self):
orig_ks_domains_list = self.openstack_driver._ks_domains_list
orig_ks_domain_get = self.openstack_driver._ks_domain_get
try:
self.openstack_driver._ks_domains_list = self.openstack_driver._ksv3_domains_list
self.openstack_driver._ks_domain_get = self.openstack_driver._ksv3_domain_get
logger.info('Creating first domain in "keystone"')
dom_id = str(uuid.uuid4())
dom_name = self.id()
test_case.get_keystone_client().domains.add_domain(
dom_id, dom_name)
dom_obj = self._vnc_lib.domain_read(id=dom_id)
self.assertThat(dom_obj.name, Equals(dom_name))
# create a project under domain so synch delete of domain fails
proj_obj = vnc_api.Project('proj-%s' % (self.id()), dom_obj)
self._vnc_lib.project_create(proj_obj)
logger.info(
'Creating second domain with same name diff id in "keystone"')
new_dom_id = str(uuid.uuid4())
test_case.get_keystone_client().domains.add_domain(
new_dom_id, dom_name)
new_dom_obj = self._vnc_lib.domain_read(id=new_dom_id)
self.assertThat(new_dom_obj.name, Not(Equals(dom_name)))
self.assertThat(new_dom_obj.name, Contains(dom_name))
self.assertThat(new_dom_obj.display_name, Equals(dom_name))
self._vnc_lib.project_delete(id=proj_obj.uuid)
self._vnc_lib.domain_delete(id=dom_id)
self._vnc_lib.domain_delete(id=new_dom_id)
finally:
self.openstack_driver._ks_domains_list = orig_ks_domains_list
self.openstack_driver._ks_domain_get = orig_ks_domain_get
def test_name_change(self):
proj_obj = vnc_api.Project('project-%s' % self.id())
self._vnc_lib.project_create(proj_obj)
for res_type in [
'network', 'subnet', 'security_group', 'port', 'router'
]:
# create a resource
res_name = '%s-%s' % (res_type, self.id())
res_q = self._create_resource_with_fallback(
res_type, proj_obj.uuid, extra_res_fields={'name': res_name})
self.assertThat(res_q['name'], Equals(res_name))
if res_type != 'subnet':
self.assertThat(res_q['fq_name'], Contains(res_name))
# change its name
# new_res_name, res_q = self._change_resource_name(res_type, res_q)
new_res_name = 'new-%s' % res_name
res_q = self.update_resource(
res_type,
res_q['id'],
proj_obj.uuid,
extra_res_fields={'name': new_res_name})
self.assertThat(res_q['name'], Equals(new_res_name))
if res_type != 'subnet':
self.assertThat(res_q['fq_name'], Contains(res_name))
self.assertThat(res_q['fq_name'], Not(Contains(new_res_name)))
# list by filter of new name
res_list = self.list_resource(res_type,
proj_uuid=proj_obj.uuid,
req_filters={'name': new_res_name})
self.assertThat(len(res_list), Equals(1))
self.assertThat(res_list[0]['name'], Equals(new_res_name))
def project_read(self, **kwargs):
fq_name_str = None
uid = None
if 'id' in kwargs:
if 'project' not in self.resources_collection or (
kwargs['id'] not in self.resources_collection['project']):
fq_name_str = "default-domain:%s" % kwargs['id']
uid = kwargs['id']
if ('fq_name_str' in kwargs
or ('fq_name' in kwargs and kwargs['fq_name'])):
fq_name_str = (kwargs['fq_name_str'] if 'fq_name_str' in kwargs
else ':'.join(kwargs['fq_name']))
if 'project' not in self.resources_collection or (
fq_name_str
and fq_name_str not in (self.resources_collection['project'])):
fq_name = fq_name_str.split(":")
domain_obj = self.domain_read(fq_name_str=fq_name[0])
proj_obj = vnc_api.Project(parent_obj=domain_obj, name=fq_name[-1])
if uid:
proj_obj.uuid = uid
self.project_create(proj_obj)
return MockVnc.ReadCallables('project',
self.resources_collection['project'],
self.resources_collection, self)(**kwargs)
def __init__(self, vnc_cfg, auth_cfg=None):
if auth_cfg is None:
auth_cfg = {}
self.vnc_lib = vnc_api.VncApi(
api_server_host=vnc_cfg.get("api_server_host"),
api_server_port=vnc_cfg.get("api_server_port"),
api_server_use_ssl=vnc_cfg.get("api_server_use_ssl"),
apicertfile=vnc_cfg.get("api_certfile"),
apikeyfile=vnc_cfg.get("api_keyfile"),
apicafile=vnc_cfg.get("api_cafile"),
apiinsecure=vnc_cfg.get("api_server_insecure"),
username=auth_cfg.get("auth_user"),
password=auth_cfg.get("auth_password"),
tenant_name=auth_cfg.get("auth_tenant"),
auth_token_url=auth_cfg.get("auth_token_url"),
)
self.project_name = vnc_cfg.get("project_name", "test-vcenter-fabric")
try:
self.vnc_lib.project_create(
vnc_api.Project(name=self.project_name)
)
except vnc_api.RefsExistError:
pass
self.fabric_name = vnc_cfg.get("fabric_name", "test-fabric")
self.create_fabric()
def test_uuid(self):
proj_obj = vnc_api.Project('project-%s' % self.id())
self._vnc_lib.project_create(proj_obj)
for res_type in ['network', 'subnet', 'security_group', 'port', 'router']:
res_uuid = str(uuid.uuid4())
res_name = '%s-%s' % (res_type, res_uuid)
res_q = self._create_resource_with_fallback(res_type, proj_obj.uuid, extra_res_fields={'name': res_name, 'id': res_uuid})
self.assertThat(res_q['id'], Equals(res_uuid))
def _ksv2_sync_project_to_vnc(self, id=None):
self._get_keystone_conn()
self._get_vnc_conn()
ks_project = self._ks_project_get(id=id.replace('-', ''))
proj_obj = vnc_api.Project(ks_project['name'])
proj_obj.uuid = id
self._vnc_lib.project_create(proj_obj)
def _ksv3_sync_project_to_vnc(self, id=None, name=None):
self._get_keystone_conn()
self._get_vnc_conn()
if id:
ks_project = \
self._ks_project_get(id=id.replace('-', ''))
display_name = ks_project['name']
project_id = id
elif name:
ks_project = \
self._ks_project_get(name=name)
project_id = ks_project['id']
display_name = name
domain_uuid = self._ksv3_domain_id_to_uuid(ks_project['domain_id'])
dom_obj = self._vnc_lib.domain_read(id=domain_uuid)
# if earlier project exists with same name but diff id,
# create with uniqified fq_name
fq_name = dom_obj.get_fq_name() + [display_name]
project_name = display_name
try:
old_id = self._vnc_lib.fq_name_to_id('project', fq_name)
if old_id == project_id:
self._vnc_project_ids.add(project_id)
return
# Project might have been quickly deleted + added.
# Since project delete sync happens only in timer(polling),
# try deleting old one synchronously. If delete fails due
# to resources being present in project, proceed/fail
# based on configuration
try:
self._vnc_lib.project_delete(fq_name=fq_name)
except vnc_api.NoIdError:
pass
except vnc_api.RefsExistError:
if self._resync_stale_mode == 'new_unique_fqn':
project_name = '%s-%s' %(display_name, str(uuid.uuid4()))
else:
errmsg = "Old project %s fqn %s exists and not empty" %(
old_id, fq_name)
self._sandesh_logger.error(errmsg)
raise Exception(errmsg)
except vnc_api.NoIdError:
pass
proj_obj = vnc_api.Project(project_name, parent_obj=dom_obj)
if self._contrail_vcenter_mode == 'vcenter_only':
id_perms = IdPermsType(enable=True,
creator="vcenter-plugin",
description="contrail api synced from keystone")
proj_obj.set_id_perms(id_perms)
proj_obj.display_name = display_name
proj_obj.uuid = project_id
self._vnc_lib.project_create(proj_obj)
self._vnc_domain_ids.add(domain_uuid)
self._vnc_project_ids.add(project_id)
def _create_no_rule_sg(self):
domain_obj = vnc_api.Domain(SG_NO_RULE_FQ_NAME[0])
proj_obj = vnc_api.Project(SG_NO_RULE_FQ_NAME[1], domain_obj)
sg_rules = vnc_api.PolicyEntriesType()
id_perms = vnc_api.IdPermsType(
enable=True,
description="Security group with no rules",
user_visible=False)
sg_obj = vnc_api.SecurityGroup(name=SG_NO_RULE_NAME,
parent_obj=proj_obj,
security_group_entries=sg_rules,
id_perms=id_perms)
self._resource_create(sg_obj)
return sg_obj
def pre_project_read_fqname(self, fq_name):
if not self._keystone_sync_on_demand or fq_name == None:
# project added via poll
return
name = fq_name[-1]
id = self._openstack_drv._ks_project_get(id=None, name=name).get('id')
if id:
proj_obj = vnc_api.Project(name)
proj_obj.fq_name = list(fq_name)
proj_obj.display_name = name
proj_obj.uuid = str(uuid.UUID(id))
try:
self._vnc_lib.project_create(proj_obj)
except RefsExistError as e:
pass
self._openstack_drv._vnc_project_ids.add(id)
else:
raise Exception('project %s not presend in keystone' % (name))
def _ksv2_sync_project_to_vnc(self, id=None):
self._get_keystone_conn()
self._get_vnc_conn()
ks_project = self._ks_project_get(id=id.replace('-', ''))
display_name = ks_project['name']
# if earlier project exists with same name but diff id,
# create with uniqified fq_name
fq_name = ['default-domain', display_name]
try:
old_id = self._vnc_lib.fq_name_to_id('project', fq_name)
proj_name = '%s-%s' % (display_name, str(uuid.uuid4()))
except vnc_api.NoIdError:
proj_name = display_name
proj_obj = vnc_api.Project(proj_name)
proj_obj.uuid = id
self._vnc_lib.project_create(proj_obj)
def _get_netipam_obj(self, ipam_fq_name=None, vn_obj=None):
if ipam_fq_name:
domain_name, project_name, ipam_name = ipam_fq_name
domain_obj = vnc_api.Domain(domain_name)
project_obj = vnc_api.Project(project_name, domain_obj)
netipam_obj = vnc_api.NetworkIpam(ipam_name, project_obj)
return netipam_obj
if vn_obj:
try:
ipam_fq_name = vn_obj.get_fq_name()[:-1]
ipam_fq_name.append('default-network-ipam')
netipam_obj = self._vnc_lib.network_ipam_read(
fq_name=ipam_fq_name)
except vnc_exc.NoIdError:
netipam_obj = vnc_api.NetworkIpam()
return netipam_obj
def _ksv3_sync_project_to_vnc(self, id=None, name=None):
self._get_keystone_conn()
self._get_vnc_conn()
if id:
ks_project = \
self._ks_project_get(id=id.replace('-', ''))
project_name = ks_project['name']
project_id = id
elif name:
ks_project = \
self._ks_project_get(name=name)
project_id = ks_project['id']
project_name = name
domain_uuid = self._ksv3_domain_id_to_uuid(ks_project['domain_id'])
dom_obj = self._vnc_lib.domain_read(id=domain_uuid)
proj_obj = vnc_api.Project(project_name, parent_obj=dom_obj)
proj_obj.uuid = project_id
self._vnc_lib.project_create(proj_obj)
def neutron_dict_to_vn(self, vn_obj, network_q):
net_name = network_q.get('name')
if net_name:
vn_obj.display_name = net_name
id_perms = vn_obj.get_id_perms()
if 'admin_state_up' in network_q:
id_perms.enable = network_q['admin_state_up']
vn_obj.set_id_perms(id_perms)
if 'policys' in network_q:
policy_fq_names = network_q['policys']
# reset and add with newly specified list
vn_obj.set_network_policy_list([], [])
seq = 0
for p_fq_name in policy_fq_names:
domain_name, project_name, policy_name = p_fq_name
domain_obj = vnc_api.Domain(domain_name)
project_obj = vnc_api.Project(project_name, domain_obj)
policy_obj = vnc_api.NetworkPolicy(policy_name, project_obj)
vn_obj.add_network_policy(
policy_obj,
vnc_api.VirtualNetworkPolicyType(
sequence=vnc_api.SequenceType(seq, 0)))
seq = seq + 1
if 'route_table' in network_q:
rt_fq_name = network_q['route_table']
if rt_fq_name:
try:
rt_obj = self._vnc_lib.route_table_read(fq_name=rt_fq_name)
vn_obj.set_route_table(rt_obj)
except vnc_api.NoIdError:
# TODO() add route table specific exception
self._raise_contrail_exception(
'NetworkNotFound', net_id=vn_obj.uuid,
resource='network')
return vn_obj
def _ksv2_sync_project_to_vnc(self, id=None):
self._get_keystone_conn()
self._get_vnc_conn()
ks_project = self._ks_project_get(id=id.replace('-', ''))
display_name = ks_project['name']
proj_name = display_name
# if earlier project exists with same name but diff id,
# create with uniqified fq_name
fq_name = ['default-domain', display_name]
try:
old_id = self._vnc_lib.fq_name_to_id('project', fq_name)
if old_id == id:
self._vnc_project_ids.add(id)
return
# Project might have been quickly deleted + added.
# Since project delete sync happens only in timer(polling),
# try deleting old one synchronously. If delete fails due
# to resources being present in project, proceed/fail
# based on configuration
try:
self._vnc_lib.project_delete(fq_name=fq_name)
except vnc_api.NoIdError:
pass
except vnc_api.RefsExistError:
if self._resync_stale_mode == 'new_unique_fqn':
proj_name = '%s-%s' % (display_name, str(uuid.uuid4()))
else:
errmsg = "Old project %s fqn %s exists and not empty" % (
old_id, fq_name)
self._sandesh_logger.error(errmsg)
raise Exception(errmsg)
except vnc_api.NoIdError:
pass
proj_obj = vnc_api.Project(proj_name)
proj_obj.display_name = display_name
proj_obj.uuid = id
self._vnc_lib.project_create(proj_obj)
self._vnc_project_ids.add(id)
def test_uuid_in_duplicate_name(self):
proj_obj = vnc_api.Project('project-%s' % self.id())
self._vnc_lib.project_create(proj_obj)
for res_type in ['network', 'subnet', 'security_group', 'port', 'router']:
# create a resource
res_uuid = str(uuid.uuid4())
res_name = '%s-%s' % (res_type, res_uuid)
res_q = self._create_resource_with_fallback(res_type, proj_obj.uuid, extra_res_fields={'name': res_name, 'id': res_uuid})
self.assertThat(res_q['name'], Equals(res_name))
self.assertThat(res_q['id'], Equals(res_uuid))
# create another resource
another_res_uuid = str(uuid.uuid4())
another_res_q = self._create_resource_with_fallback(res_type, proj_obj.uuid, extra_res_fields={'name': res_name, 'id': another_res_uuid})
if res_type != 'subnet':
expected_fq_name = "%s-%s" % (res_name, another_res_uuid)
self.assertThat(another_res_q['fq_name'][-1], Equals(expected_fq_name))
self.assertThat(another_res_q['id'], Equals(another_res_uuid))
res_list = self.list_resource(res_type, proj_uuid=proj_obj.uuid, req_filters={'name': res_name})
self.assertThat(len(res_list), Equals(2))
def _resync_projects_forever(self):
try:
# get connection to api-server REST interface
while True:
try:
self._vnc_lib = vnc_api.VncApi(
api_server_host=self._vnc_api_ip,
api_server_port=self._vnc_api_port,
username=self._auth_user,
password=self._auth_passwd,
tenant_name=self._auth_tenant)
break
except requests.ConnectionError:
gevent.sleep(1)
old_projects = self._vnc_lib.projects_list()['projects']
old_project_ids = set([proj['uuid'] for proj in old_projects])
except Exception as e:
cgitb.Hook(format="text", file=open(self._tmp_file_name,
'w')).handle(sys.exc_info())
fhandle = open(self._tmp_file_name)
self._vnc_os_logger.error("%s" % fhandle.read())
del_proj_list = set()
while True:
try:
# Get tenants/projects from Keystone and audit with api-server
self._get_keystone_conn()
# compare new and old set,
# optimize for common case where nothing has changed,
# so track the project-ids in a set add '-',
# keystone gives uuid without...
try:
new_project_ids = set([
str(uuid.UUID(proj.id))
for proj in self._kc.tenants.list()
])
except Exception as e:
self._kc = None
continue
if old_project_ids == new_project_ids:
# no change, go back to poll
gevent.sleep(self._resync_interval_secs)
continue
for old_proj_id in old_project_ids - new_project_ids:
if old_proj_id in del_proj_list:
pass
try:
self._vnc_lib.project_delete(id=old_proj_id)
except Exception as e:
cgitb.Hook(format="text",
file=open(self._tmp_file_name,
'w')).handle(sys.exc_info())
fhandle = open(self._tmp_file_name)
self._vnc_os_logger.error("%s" % fhandle.read())
del_proj_list.add(old_proj_id)
pass
for new_proj_id in new_project_ids - old_project_ids:
try:
self._vnc_lib.project_read(id=new_proj_id)
# project exists, no-op for now,
# sync any attr changes in future
except vnc_api.NoIdError:
new_proj = \
self._kc.tenants.get(new_proj_id.replace('-', ''))
p_obj = vnc_api.Project(new_proj.name)
p_obj.uuid = new_proj_id
self._vnc_lib.project_create(p_obj)
# yield, project list might be large...
gevent.sleep(0)
#end for all new projects
# we are in sync
old_project_ids = new_project_ids
except Exception as e:
self._kc = None
cgitb.Hook(format="text",
file=open(self._tmp_file_name,
'w')).handle(sys.exc_info())
fhandle = open(self._tmp_file_name)
self._vnc_os_logger.error("%s" % fhandle.read())
gevent.sleep(2)
def handle_create(self):
parent_obj = None
if parent_obj is None and self.properties.get(self.DOMAIN):
try:
parent_obj = self.vnc_lib().domain_read(
id=self.properties.get(self.DOMAIN))
except vnc_api.NoIdError:
parent_obj = self.vnc_lib().domain_read(
fq_name_str=self.properties.get(self.DOMAIN))
except:
parent_obj = None
if parent_obj is None:
raise Exception('Error: parent is not specified in template!')
obj_0 = vnc_api.Project(name=self.properties[self.NAME],
parent_obj=parent_obj)
if self.properties.get(self.ALARM_ENABLE) is not None:
obj_0.set_alarm_enable(self.properties.get(self.ALARM_ENABLE))
if self.properties.get(self.DISPLAY_NAME) is not None:
obj_0.set_display_name(self.properties.get(self.DISPLAY_NAME))
if self.properties.get(self.QUOTA) is not None:
obj_1 = vnc_api.QuotaType()
if self.properties.get(self.QUOTA,
{}).get(self.QUOTA_DEFAULTS) is not None:
obj_1.set_defaults(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_DEFAULTS))
if self.properties.get(self.QUOTA,
{}).get(self.QUOTA_FLOATING_IP) is not None:
obj_1.set_floating_ip(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_FLOATING_IP))
if self.properties.get(self.QUOTA,
{}).get(self.QUOTA_INSTANCE_IP) is not None:
obj_1.set_instance_ip(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_INSTANCE_IP))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_VIRTUAL_MACHINE_INTERFACE) is not None:
obj_1.set_virtual_machine_interface(
self.properties.get(self.QUOTA, {}).get(
self.QUOTA_VIRTUAL_MACHINE_INTERFACE))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_VIRTUAL_NETWORK) is not None:
obj_1.set_virtual_network(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_VIRTUAL_NETWORK))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_VIRTUAL_ROUTER) is not None:
obj_1.set_virtual_router(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_VIRTUAL_ROUTER))
if self.properties.get(self.QUOTA,
{}).get(self.QUOTA_VIRTUAL_DNS) is not None:
obj_1.set_virtual_DNS(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_VIRTUAL_DNS))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_VIRTUAL_DNS_RECORD) is not None:
obj_1.set_virtual_DNS_record(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_VIRTUAL_DNS_RECORD))
if self.properties.get(self.QUOTA,
{}).get(self.QUOTA_BGP_ROUTER) is not None:
obj_1.set_bgp_router(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_BGP_ROUTER))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_NETWORK_IPAM) is not None:
obj_1.set_network_ipam(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_NETWORK_IPAM))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_ACCESS_CONTROL_LIST) is not None:
obj_1.set_access_control_list(
self.properties.get(self.QUOTA, {}).get(
self.QUOTA_ACCESS_CONTROL_LIST))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_NETWORK_POLICY) is not None:
obj_1.set_network_policy(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_NETWORK_POLICY))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_FLOATING_IP_POOL) is not None:
obj_1.set_floating_ip_pool(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_FLOATING_IP_POOL))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_SERVICE_TEMPLATE) is not None:
obj_1.set_service_template(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_SERVICE_TEMPLATE))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_SERVICE_INSTANCE) is not None:
obj_1.set_service_instance(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_SERVICE_INSTANCE))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_LOGICAL_ROUTER) is not None:
obj_1.set_logical_router(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_LOGICAL_ROUTER))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_SECURITY_GROUP) is not None:
obj_1.set_security_group(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_SECURITY_GROUP))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_SECURITY_GROUP_RULE) is not None:
obj_1.set_security_group_rule(
self.properties.get(self.QUOTA, {}).get(
self.QUOTA_SECURITY_GROUP_RULE))
if self.properties.get(self.QUOTA,
{}).get(self.QUOTA_SUBNET) is not None:
obj_1.set_subnet(
self.properties.get(self.QUOTA, {}).get(self.QUOTA_SUBNET))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_GLOBAL_VROUTER_CONFIG) is not None:
obj_1.set_global_vrouter_config(
self.properties.get(self.QUOTA, {}).get(
self.QUOTA_GLOBAL_VROUTER_CONFIG))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_LOADBALANCER_POOL) is not None:
obj_1.set_loadbalancer_pool(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_LOADBALANCER_POOL))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_LOADBALANCER_MEMBER) is not None:
obj_1.set_loadbalancer_member(
self.properties.get(self.QUOTA, {}).get(
self.QUOTA_LOADBALANCER_MEMBER))
if self.properties.get(self.QUOTA, {}).get(
self.QUOTA_LOADBALANCER_HEALTHMONITOR) is not None:
obj_1.set_loadbalancer_healthmonitor(
self.properties.get(self.QUOTA, {}).get(
self.QUOTA_LOADBALANCER_HEALTHMONITOR))
if self.properties.get(self.QUOTA,
{}).get(self.QUOTA_VIRTUAL_IP) is not None:
obj_1.set_virtual_ip(
self.properties.get(self.QUOTA,
{}).get(self.QUOTA_VIRTUAL_IP))
obj_0.set_quota(obj_1)
# reference to namespace_refs
obj_1 = None
if self.properties.get(self.NAMESPACE_REFS_DATA) is not None:
for index_0 in range(
len(self.properties.get(self.NAMESPACE_REFS_DATA))):
obj_1 = vnc_api.SubnetType()
if self.properties.get(
self.NAMESPACE_REFS_DATA, {})[index_0].get(
self.NAMESPACE_REFS_DATA_IP_PREFIX) is not None:
obj_1.set_ip_prefix(
self.properties.get(
self.NAMESPACE_REFS_DATA, {})[index_0].get(
self.NAMESPACE_REFS_DATA_IP_PREFIX))
if self.properties.get(
self.NAMESPACE_REFS_DATA,
{})[index_0].get(
self.NAMESPACE_REFS_DATA_IP_PREFIX_LEN) is not None:
obj_1.set_ip_prefix_len(
self.properties.get(
self.NAMESPACE_REFS_DATA, {})[index_0].get(
self.NAMESPACE_REFS_DATA_IP_PREFIX_LEN))
if self.properties.get(self.NAMESPACE_REFS):
try:
ref_obj = self.vnc_lib().namespace_read(
id=self.properties.get(
self.NAMESPACE_REFS)[index_0])
except vnc_api.NoIdError:
ref_obj = self.vnc_lib().namespace_read(
fq_name_str=self.properties.get(
self.NAMESPACE_REFS)[index_0])
obj_0.add_namespace(ref_obj, obj_1)
# reference to floating_ip_pool_refs
if self.properties.get(self.FLOATING_IP_POOL_REFS):
for index_0 in range(
len(self.properties.get(self.FLOATING_IP_POOL_REFS))):
try:
ref_obj = self.vnc_lib().floating_ip_pool_read(
id=self.properties.get(
self.FLOATING_IP_POOL_REFS)[index_0])
except vnc_api.NoIdError:
ref_obj = self.vnc_lib().floating_ip_pool_read(
fq_name_str=self.properties.get(
self.FLOATING_IP_POOL_REFS)[index_0])
obj_0.add_floating_ip_pool(ref_obj)
# reference to alias_ip_pool_refs
if self.properties.get(self.ALIAS_IP_POOL_REFS):
for index_0 in range(
len(self.properties.get(self.ALIAS_IP_POOL_REFS))):
try:
ref_obj = self.vnc_lib().alias_ip_pool_read(
id=self.properties.get(
self.ALIAS_IP_POOL_REFS)[index_0])
except vnc_api.NoIdError:
ref_obj = self.vnc_lib().alias_ip_pool_read(
fq_name_str=self.properties.get(
self.ALIAS_IP_POOL_REFS)[index_0])
obj_0.add_alias_ip_pool(ref_obj)
try:
obj_uuid = super(ContrailProject, self).resource_create(obj_0)
except:
raise Exception(_('project %s could not be updated.') % self.name)
self.resource_id_set(obj_uuid)
def project():
proj = vnc_api.Project(name='project-name',
parent_obj=vnc_api.Domain(name='domain-name'))
proj.set_uuid('project-uuid')
return proj
def construct_project():
return vnc_api.Project(name=VNC_VCENTER_PROJECT)
def setUp(self):
super(TestTrunk, self).setUp()
self.project_id = self._vnc_lib.project_create(
vnc_api.Project('project-%s' % self.id()))
self.project = self._vnc_lib.project_read(id=self.project_id)
def project():
return vnc_api.Project()
