def test_missing(self):
depl = resource.VmmInjectedDeployment(
**{
'display_name': '',
'name': 'kubedns',
'replicas': 1,
'domain_name': 'kube',
'controller_name': 'kube',
'domain_type': 'Kubernetes',
'guid': 'a',
'namespace_name': 'k'
})
ns = resource.VmmInjectedNamespace(
**{
'display_name': '',
'name': 'k',
'domain_name': 'kube',
'controller_name': 'kube',
'domain_type': 'Kubernetes'
})
updates = [depl, ns, ns]
mgr = aim_manager.AimManager()
tt_maker = tree_manager.AimHashTreeMaker()
tt_builder = tree_manager.HashTreeBuilder(mgr)
trees = {}
exp_key = tt_maker._build_hash_tree_key(depl)
for aim_res in updates:
key = tt_maker.get_root_key(aim_res)
if key and trees is not None:
cfg = trees.setdefault(tt_builder.CONFIG, {}).setdefault(
key, tree.StructuredHashTree())
mo = trees.setdefault(tt_builder.MONITOR,
{}).setdefault(key,
tree.StructuredHashTree())
oper = trees.setdefault(tt_builder.OPER, {}).setdefault(
key, tree.StructuredHashTree())
tt_builder.build(
[aim_res], [], [], {
tt_builder.CONFIG: {
key: cfg
},
tt_builder.MONITOR: {
key: mo
},
tt_builder.OPER: {
key: oper
}
},
aim_ctx=self.ctx)
if not isinstance(aim_res, resource.VmmInjectedDeployment):
self.assertIsNotNone(cfg.find(exp_key),
'Resource %s' % aim_res)
self.assertIsNotNone(trees['config']['comp'].find(exp_key),
'Resource %s' % aim_res)
def _remove_data_from_tree(self, data, state):
aim_res = converter.AciToAimModelConverter().convert(data)
by_root = {}
for res in aim_res:
by_root.setdefault(res.root, []).append(res)
for root, updates in by_root.iteritems():
tree_manager.AimHashTreeMaker().delete(
state.setdefault(root, structured_tree.StructuredHashTree()),
updates)
def _retrieve_tenant_rn(self, data):
if isinstance(data, dict):
if data.keys()[0] == 'tagInst':
# Retrieve tag parent
dn = data.values()[0]['attributes']['dn']
decomposed = apic_client.DNManager().aci_decompose_dn_guess(
dn, 'tagInst')
parent_type = decomposed[1][-2][0]
data = {
parent_type: {
'attributes': {
'dn': apic_client.DNManager().build(
decomposed[1][:-1])}}}
data = self._aim_converter.convert([data])
data = data[0] if data else None
if isinstance(data, resource.AciResourceBase):
return tree_manager.AimHashTreeMaker().get_root_key(data)
def __init__(self, ctx=None, *args, **kwargs):
self.ctx = ctx or context.AimContext(store=api.get_store())
if 'streaming' not in self.ctx.store.features:
# TODO(ivar) raise something meaningful
raise Exception
self.mgr = aim_manager.AimManager()
self.tt_mgr = tree_manager.HashTreeManager()
self.tt_maker = tree_manager.AimHashTreeMaker()
self.tt_builder = tree_manager.HashTreeBuilder(self.mgr)
self.klient = self.ctx.store.klient
self.namespace = self.ctx.store.namespace
self.trees = {}
self.q = queue.Queue()
self.event_handler = event_handler.EventHandler
self._stop = False
self._http_resp = None
# Tenants whose trees need to be saved in AIM
self.affected_tenants = set()
self._observe_thread_state = {}
self._k8s_types_to_observe = set([])
self._k8s_aim_type_map = {}
self._k8s_kinds = set([])
self._needs_init = True
for aim_res in aim_manager.AimManager.aim_resources:
if issubclass(aim_res, resource.AciResourceBase):
k8s_type = self.ctx.store.resource_to_db_type(aim_res)
for ktype in ([k8s_type] + k8s_type.aux_objects.values()):
self._k8s_types_to_observe.add(ktype)
self._k8s_kinds.add(ktype.kind)
if ktype != api_v1.AciContainersObject:
self._k8s_aim_type_map[ktype.kind] = (aim_res,
k8s_type)
self._event_filters = {
api_v1.Pod: self._pod_event_filter,
api_v1.Endpoints: self._endpoints_event_filter
}
def test_sync_object_status(self):
mgr = aim_manager.AimManager()
epg = mgr.create(
self.ctx,
resource.EndpointGroup(tenant_name='test',
app_profile_name='test',
name='test',
sync=False))
status = mgr.get_status(self.ctx, epg)
mgr.update(self.ctx, status, sync_status=status.SYNCED)
tt_builder = tree_manager.HashTreeBuilder(mgr)
trees = {}
tt_maker = tree_manager.AimHashTreeMaker()
key = tt_maker.get_root_key(epg)
cfg = trees.setdefault(tt_builder.CONFIG,
{}).setdefault(key, tree.StructuredHashTree())
mo = trees.setdefault(tt_builder.MONITOR,
{}).setdefault(key, tree.StructuredHashTree())
oper = trees.setdefault(tt_builder.OPER,
{}).setdefault(key, tree.StructuredHashTree())
tt_builder.build(
[status], [], [], {
tt_builder.CONFIG: {
key: cfg
},
tt_builder.MONITOR: {
key: mo
},
tt_builder.OPER: {
key: oper
}
},
aim_ctx=self.ctx)
# Should not add parent back
exp_key = tt_maker._build_hash_tree_key(epg)
self.assertIsNone(cfg.find(exp_key))
def __init__(self, aim_manager):
self.aim_manager = aim_manager
self.tt_mgr = tree_manager.HashTreeManager()
self.tt_maker = tree_manager.AimHashTreeMaker()
self.tt_builder = tree_manager.HashTreeBuilder(self.aim_manager)
def setUp(self):
super(TestAimHashTreeMaker, self).setUp()
self.maker = tree_manager.AimHashTreeMaker()
