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 __init__(self,
tenant_name,
apic_config,
apic_session,
ws_context,
creation_succeeded=None,
creation_failed=None,
aim_system_id=None,
get_resources=None,
*args,
**kwargs):
super(AciTenantManager, self).__init__(*args, **kwargs)
LOG.info("Init manager for tenant %s" % tenant_name)
self.get_resources = get_resources
self.apic_config = apic_config
# Each tenant has its own sessions
self.aci_session = apic_session
self.dn_manager = apic_client.DNManager()
self.tenant_name = tenant_name
children_mos = get_children_mos(self.aci_session, self.tenant_name)
ws_subscription_to = self.apic_config.get_option(
'websocket_subscription_timeout', 'aim') or DEFAULT_WS_TO
self.tenant = Root(self.tenant_name,
filtered_children=children_mos,
rn=self.tenant_name,
ws_subscription_to=ws_subscription_to)
self._state = structured_tree.StructuredHashTree()
self._operational_state = structured_tree.StructuredHashTree()
self._monitored_state = structured_tree.StructuredHashTree()
self.polling_yield = self.apic_config.get_option(
'aci_tenant_polling_yield', 'aim')
self.to_aim_converter = converter.AciToAimModelConverter()
self.to_aci_converter = converter.AimToAciModelConverter()
self._reset_object_backlog()
self.tree_builder = tree_manager.HashTreeBuilder(None)
self.tag_name = aim_system_id or self.apic_config.get_option(
'aim_system_id', 'aim')
self.tag_set = set()
self.failure_log = {}
def noop(*args, **kwargs):
pass
self.creation_succeeded = creation_succeeded or noop
self.creation_failed = creation_failed or noop
# Warm bit to avoid rushed synchronization before receiving the first
# batch of APIC events
self._warm = False
self.ws_context = ws_context
self.recovery_retries = None
self.max_retries = 5
self.error_handler = error.APICAPIErrorHandler()
# For testing purposes
self.num_loop_runs = float('inf')
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)