def store_structure(device, feature):
# get feature and attributes
[(ft, attr)] = feature.items()
log.info(
banner("Learning '{n}' feature with "
"attribues {a} on device {d}".format(n=ft, a=attr,
d=device)))
# perform lookup per device
lib = Lookup.from_device(device)
# attach ops and conf
lib.conf = getattr(lib, 'conf', conf)
lib.ops = getattr(lib, 'ops', ops)
# create the ops/conf instance
try:
obj = attrgetter(ft)(lib)
except Exception:
raise AttributeError('Cannot load %s for '
'device %s.' % (ft, device.name))
# conf learn_config
if issubclass(obj, ConfBase):
ret = obj.learn_config(device=device, attributes=attr)
ret = _to_dict(ret[0])
# delete the non-used objects for pcall to retrun
ret.pop('__testbed__')
ret.pop('devices')
ret.pop('interfaces')
remove_parent_from_conf_dict(ret['device_attr'][device.name])
elif issubclass(obj, OpsBase):
ret = obj(device, attributes=attr)
ret.learn()
temp = AttrDict()
temp.info = getattr(ret, 'info', {})
ret = temp
ret_dict = {}
ret_dict.setdefault('lts', {}).\
setdefault(ft, {}).setdefault(device.name, ret)
# return the dictionary
return ret_dict
def _verify_conf_2(self, device, verify_conf, reqs, missing, ops,
requirements):
o = verify_conf.learn_config(device=device)
# convert from conf instance to dictionary
o = [_to_dict(item) for item in o]
# Make sure that configured path is correctly configured
try:
self._verify_finds_ops(ops=o[0], requirements=reqs['list'],
missing=missing, obj_mod=ops,
org_req=requirements)
except ValueError as e:
raise e
except Exception as e:
raise Exception("Could not verify the configuration was "
"applied correctly as per the exception: "
"{e}".format(e=e))
def _learn_base(self, device, name, step, abstracted_base, is_ops, base,
requirements, verify=False, verify_find=None, **kwargs):
try:
# Populate the kwargs
kwargs.update(requirements.get('kwargs', {}))
requirements_ = requirements.get('requirements', [])
exclude = requirements.get('exclude', [])
all_keys = requirements.get('all_keys', False)
if requirements_:
# Populate the keys into R object
# Useful if want to learn from previously learnt requirements
requirements_ = self._populate_path(requirements_, device,
keys=self.keys)
# process ops requirements
if is_ops:
o = abstracted_base(device=device, **kwargs)
learn_poll = {}
if not verify:
if not verify_find:
verify_find = self._verify_find
# First time we learn, no need to loop
learn_poll['attempt'] = 1
learn_poll['sleep'] = 0
learn_poll['verify'] = verify_find
learn_poll['all_keys'] = all_keys
learn_poll['requirements'] = requirements_
else:
learn_poll = {'timeout': self.timeout}
if not verify_find:
verify_find = self._verify_same
name = o.__class__ if hasattr(o, '__class__') else o
log.info("Learning '{n}' feature".format(n=name))
learn_poll['initial'] = self._ops_ret[base]
learn_poll['verify'] = verify_find
learn_poll['exclude'] = self._populate_exclude(exclude)
learn_poll.update(kwargs)
# skip the learning for verify
if base not in self._ops_ret:
return o
# Learn and verify the ops
o.learn_poll(**learn_poll)
return o
# process conf requirements
else:
# import conf module
## get conf class
cls = abstracted_base
if issubclass(cls, ConfBase):
if verify:
name = cls.__name__ if hasattr(cls, '__name__') else cls
log.info("Learning '{n}' feature".format(n=name))
# skip the learning for verify
if base not in self._conf_ret:
return
# learn conf with show running-config
o = cls.learn_config(device=device)
# convert from conf instance to dictionary
o = [_to_dict(item) for item in o]
if verify:
# sort both list
initial = sorted(self._conf_ret[base])[:1]
restore = sorted(o)[:1]
# compare lengh to begin with
len_initial = len(initial)
len_restore = len(restore)
if len_initial != len_restore:
raise Exception("Current ops is not equal "
"to the initial Snapshot "
"taken\n{} != {}".format(
len_initial, len_restore))
# zip and verify whether they are the same
for before, after in zip(initial, restore):
# verify conf
self._verify_same(after, before, exclude)
else:
for item in o:
# verify requirements
self._verify_find(item, requirements_, all_keys)
return o[:1]
except Exception as e:
raise