def test_collection_detail(self, mock_session):
mock_session.configure_mock(base_url=BASE)
c = Collection('foo', fields=['foo', 'bar'], detail=True, fetch=True)
mock_session.get_json.assert_called_with(BASE + '/foos', detail=True)
c.fetch(fields=['baz'])
mock_session.get_json.assert_called_with(BASE + '/foos', detail=True)
c.fetch()
mock_session.get_json.assert_called_with(BASE + '/foos', detail=True)
c = Collection('foo', detail=True, fetch=True)
mock_session.get_json.assert_called_with(c.href, detail=True)
c = Collection('foo', detail=False, fetch=True)
mock_session.get_json.assert_called_with(c.href)
c = Collection('foo', detail='other', fetch=True)
mock_session.get_json.assert_called_with(c.href)
mock_session.get_json.return_value = {
'foos': [{
'foo': {
'uuid': 'dd2f4111-abda-405f-bce9-c6c24181dd14',
}
}, {
'foo': {
'uuid': '9fe7094d-f54e-4284-a813-9ca4df866019',
}
}]
}
c = Collection('foo', detail=True, fetch=True)
self.assertEqual(
c.data[0],
Resource('foo', uuid='dd2f4111-abda-405f-bce9-c6c24181dd14'))
self.assertEqual(
c.data[1],
Resource('foo', uuid='9fe7094d-f54e-4284-a813-9ca4df866019'))
def __call__(self, filename):
self.graph = nx.DiGraph()
cols = [
Collection(r, fetch=True, detail=True) for r in [
"virtual-machine-interface", "virtual-network", "instance-ip",
"loadbalancer-pool", "virtual-ip", "instance-ip",
"logical-router", "floating-ip", "service-template",
"service-instance"
]
]
def add_node(g, r):
self.graph.add_node(r.uuid,
type=r.type,
fq_name=":".join(r.fq_name),
name=r.fq_name[-1])
for e in chain(*cols):
add_node(self.graph, e)
for r in e.refs:
add_node(self.graph, r)
self.graph.add_edge(e.uuid, r.uuid)
self._to_graphml(filename)
def __call__(self):
sass = Collection('service-appliance-set', fetch=True, recursive=2)
return json.dumps([{
'appliance_set_name': sas.fq_name[-1],
'driver': sas['service_appliance_driver']
} for sas in sass if 'service_appliance_driver' in sas],
indent=2)
def __call__(self):
vrouters = Collection('virtual-router', fetch=True, recursive=2)
return json.dumps(
[{
'vrouter_name': vrouter.fq_name[-1],
'vrouter_ip': vrouter['virtual_router_ip_address'],
'vrouter_type': vrouter.get('virtual_router_type', [])
} for vrouter in vrouters],
indent=2)
def __call__(self, project_fqname=None):
project = Resource('project', fq_name=project_fqname, check=True)
vns = Collection('virtual-network',
parent_uuid=project.uuid,
fetch=True,
recursive=2)
return json.dumps([{
"virtual_network_name": vn.fq_name[-1],
"project_fqname": str(FQName(vn.fq_name[0:-1])),
"shared": vn.get('is_shared', False),
"external": vn.get('router_external', False),
} for vn in vns],
indent=2)
def __call__(self, force=False, parent_type=None, cassandra_servers=None):
valid_acl = []
parents = Collection(parent_type, fetch=True, recursive=2)
for parent in parents:
if 'access_control_lists' in parent.keys():
valid_acl += [
acl['uuid'] for acl in parent['access_control_lists']
]
valid_acl = list(set(valid_acl))
orphaned_acls = set([])
# Due to a bug in contrail API, we cannot list more than 10000 elements
# on a resource and there is no way to list ACL by tenant.
# So that ugly hack directly fetch all ACL UUIDs from the cassandra database :(
pool = ConnectionPool('config_db_uuid', server_list=cassandra_servers)
fqname_cf = ColumnFamily(pool, 'obj_fq_name_table')
for key, value in fqname_cf.xget('access_control_list'):
acl_uuid = decode_string(key).split(':')[-1]
if acl_uuid in valid_acl:
continue
acl = Resource('access-control-list', uuid=acl_uuid, fetch=True)
if ('parent_uuid' in acl.keys() and 'parent_type' in acl.keys()
and acl['parent_type'] == parent_type
and acl.uuid not in valid_acl):
try:
parent_acl = acl.parent
except ResourceNotFound:
msg = ("The %s parent ACL %s was not found." %
(parent_type.replace('-', ' '), acl['parent_uuid']))
if force:
msg = msg + " Delete orphan ACL %s." % acl.uuid
acl.delete()
logger.debug(msg)
orphaned_acls.add(acl['uuid'])
else:
logger.debug(
"The ACL %(acl)s have a %(parent_type)s %(parent_acl)s which exists but \
was not found in the precedent %(parent_type)s list. Not delete it."
% {
'acl': acl,
'parent_type': parent_type.replace('-', ' '),
'parent_acl': parent_acl
})
if force:
logger.debug("%d orphaned ACL were deleted" % len(orphaned_acls))
else:
logger.debug("Found %d orphaned ACL to delete" %
len(orphaned_acls))
def generate(self, vn_paths):
result = []
if vn_paths == []:
vns = Collection("virtual-network", fetch=True, detail=True)
else:
vns = expand_paths(vn_paths)
for vn in vns:
vn.fetch()
for r in vns:
nid = r["virtual_network_network_id"]
try:
zk_data, _ = self.zk_client.get(ZK_BASEPATH + "/" + to_zk_index(nid))
except kazoo.exceptions.NoNodeError:
result.append({"reason": "nolock", "nid": nid, "path": r.path, "api-fqname": text_type(r.fq_name), "resource": r})
continue
if "%s" % zk_data.decode('utf-8') != "%s" % r.fq_name:
result.append({"reason": "badlock", "nid": nid, "path": r.path, "api-fqname": text_type(r.fq_name), "zk-fqname": zk_data, "resource": r})
return result
def __call__(self):
routers = Collection('bgp-router', fetch=True, recursive=2)
return json.dumps([{
'router_name':
router.fq_name[-1],
'router_ip':
router['bgp_router_parameters']['address'],
'router_port':
router['bgp_router_parameters']['port'],
'router_asn':
router['bgp_router_parameters']['autonomous_system'],
'router_type':
router['bgp_router_parameters']['vendor'],
'router_address_families':
router['bgp_router_parameters']['address_families']['family'],
'router_md5':
router['bgp_router_parameters']['auth_data']['key_items'][0]['key']
if 'auth_data' in router['bgp_router_parameters']
and router['bgp_router_parameters']['auth_data'] else []
} for router in routers],
indent=2)
def __call__(self,
router_name=None,
router_ip=None,
router_port=None,
router_asn=None,
router_address_families=[],
router_type=None,
router_md5=None):
default_ri = Resource('routing-instance',
fq_name=DEFAULT_RI_FQ_NAME,
check=True)
router_fq_name = DEFAULT_RI_FQ_NAME + [router_name]
bgp_router = Resource('bgp-router', fq_name=router_fq_name)
if bgp_router.exists:
raise CommandError("The BGP router %s already exists" %
FQName(router_fq_name))
if router_type != 'contrail' and 'erm-vpn' in router_address_families:
router_address_families.remove('erm-vpn')
auth_data = None
if router_md5:
auth_data = {
'key_items': [{
'key': router_md5,
'key_id': 0,
}],
'key_type': 'md5',
}
router_parameters = {
'address': router_ip,
'address_families': {
'family': router_address_families,
},
'autonomous_system': router_asn,
'identifier': router_ip,
'port': router_port,
'vendor': router_type,
'auth_data': auth_data,
}
# full-mesh with existing BGP routers
bgp_router_refs = []
for bgp_router_neighbor in Collection('bgp-router',
parent_uuid=default_ri.uuid,
fetch=True):
bgp_router_refs.append({
'to': bgp_router_neighbor.fq_name,
'attr': {
'session': [{
'attributes': [{
'address_families': {
'family': router_address_families,
},
'auth_data': auth_data,
}],
}],
},
})
bgp_router = Resource('bgp-router',
fq_name=router_fq_name,
parent=default_ri,
bgp_router_parameters=router_parameters,
bgp_router_refs=bgp_router_refs)
bgp_router.save()
def test_collection_with_defined_session(self):
mock_session = mock.MagicMock(base_url=self.BASE)
Collection('foo', session=mock_session, fetch=True)
mock_session.get_json.assert_called_with(self.BASE + '/foos')