def __init__(self, connection):
self._connection = connection
self._configurators = AlteonConfigurators(connection)
self._config_manager = DeviceConfigurationManager()
log.info(
' Alteon Configuration Module initialized, server: {0}'.format(
self._connection.id))
class AlteonConfiguration(BaseAPI):
def __init__(self, connection):
self._connection = connection
self._configurators = AlteonConfigurators(connection)
self._config_manager = DeviceConfigurationManager()
log.info(
' Alteon Configuration Module initialized, server: {0}'.format(
self._connection.id))
def execute(self, command, parameters, **kw):
configurator = self._find_configurator(parameters)
return self._config_manager.execute(configurator, command, parameters,
**kw)
def _find_configurator(self, parameters):
for k, v in self._configurators.__dict__.items():
if isinstance(v, DeviceConfigurator):
if v.get_parameters_class() == type(parameters):
return v
raise ArgumentNotExpectedTypeError(
parameters, 'no Configurator found for argument type')
@property
def manager(self):
return self._config_manager
@property
def type(self):
return self._configurators
def __init__(self, configurator_class, **kwargs):
self._configurator = configurator_class(self._device_connection)
self._config_manager = DeviceConfigurationManager()
self._state = self._base.params['state']
self._write_on_change = self._base.params['write_on_change']
if self._state == 'present':
self._differential_update = True
else:
self._differential_update = False
self.arguments = configurator_class.get_parameters_class()()
if self._base.params['parameters'] is None:
self._base.params['parameters'] = dict()
self.arguments.set_attributes(**self._base.params['parameters'])
self.result = {}
self.changed = False
self.changes = None
if hasattr(self._base.module, '_diff'):
self._report_diff = getattr(self._base.module, '_diff')
else:
self._report_diff = False
def collect_config_facts(self, facts_list, exclude_list):
def _translate_filter_bean(beans, bean_filter):
translated_beans = [b.obj_to_dict() for b in beans]
if bean_filter and 'exclude' in bean_filter:
for b in translated_beans:
for f_exclude in bean_filter['exclude']:
if f_exclude in b:
b.pop(f_exclude)
if bean_filter and 'include' in bean_filter:
for b in translated_beans:
for k in list(b.keys()):
if k not in bean_filter['include']:
b.pop(k)
return translated_beans
def _read_beans(b_classes):
beans_res = dict()
if b_classes:
for bean_class, bean_filter in b_classes.items():
beans = self._connection.rest.read_all(bean_class())
if beans:
beans_res.update({
bean_class.__name__:
_translate_filter_bean(beans, bean_filter)
})
return beans_res
def _collect_state_stats():
state_fact_key = ArgumentSpecs.state(key)
stats_fact_key = ArgumentSpecs.stats(key)
if ('all' in facts_list and state_fact_key
not in exclude_list) or state_fact_key in facts_list:
if hasattr(configurator, STATE_BEANS_VAR_NAME):
cfg_beans = _read_beans(
getattr(configurator, STATE_BEANS_VAR_NAME))
result.update({state_fact_key: cfg_beans})
if ('all' in facts_list and stats_fact_key
not in exclude_list) or stats_fact_key in facts_list:
if hasattr(configurator, STATS_BEANS_VAR_NAME):
cfg_beans = _read_beans(
getattr(configurator, STATS_BEANS_VAR_NAME))
result.update({stats_fact_key: cfg_beans})
result = dict()
cfg_mng = DeviceConfigurationManager()
vx_device = self._device_mng.info.is_vx
container_device = self._device_mng.info.is_container
for key in get_type_hints(AlteonConfigurators):
configurator = getattr(self._configurators, key)
if ('all' in facts_list
and key not in exclude_list) or key in facts_list:
if type(configurator) == SSLCertConfigurator and not vx_device:
result.update({
key:
cfg_mng.execute(configurator, 'read_all_cert_info',
None).content_translate
})
elif type(
configurator) == SSLKeyConfigurator and not vx_device:
result.update({
key:
cfg_mng.execute(configurator, 'read_all_key_info',
None).content_translate
})
elif type(configurator) in [
VADCInstanceConfigurator, VXPeerSyncConfigurator
] and not vx_device:
continue
elif type(configurator) in [
SystemTimeDateConfigurator, SpanningTreeConfigurator,
LLDPConfigurator, LACPAggregationConfigurator
] and not container_device:
continue
elif type(configurator) in [
SystemDNSClientConfigurator, BOOTPRelayConfigurator,
ConfigurationSyncConfigurator,
HighAvailabilityConfigurator,
GlobalRedirectionConfigurator
] and vx_device:
continue
else:
result.update({
key:
cfg_mng.execute(configurator,
DeviceConfigurator.READ_ALL,
None).content_translate
})
_collect_state_stats()
return result
class ConfigurationModule(BaseAPI):
"""
generate input param object from dict
create 'DeviceConfigurationManager' instance
execute configurator and return dict result to caller
"""
def __init__(self, configurator_class, **kwargs):
self._configurator = configurator_class(self._device_connection)
self._config_manager = DeviceConfigurationManager()
self._state = self._base.params['state']
self._write_on_change = self._base.params['write_on_change']
if self._state == 'present':
self._differential_update = True
else:
self._differential_update = False
self.arguments = configurator_class.get_parameters_class()()
if self._base.params['parameters'] is None:
self._base.params['parameters'] = dict()
self.arguments.set_attributes(**self._base.params['parameters'])
self.result = {}
self.changed = False
self.changes = None
if hasattr(self._base.module, '_diff'):
self._report_diff = getattr(self._base.module, '_diff')
else:
self._report_diff = False
@abstractmethod
def _on_error(self):
pass
@property
def command(self):
if self._state in ANSIBLE_TO_SDK_CMD:
return ANSIBLE_TO_SDK_CMD[self._state]
else:
return self._state
def exec_module(self):
def prepare_object():
device_current = self._config_manager.execute(
self._configurator, 'read', self.arguments).content_translate
if device_current is None:
return self._base.params['parameters']
if self._base.module.check_mode:
if '---' in self.changes:
for key in self.changes['---'].keys():
if key in device_current:
if type(self.changes['---'][key]) == list:
for item in self.changes['---'][key]:
device_current[key].remove(item)
else:
del device_current[key]
if '+++' in self.changes:
for key in self.changes['+++'].keys():
if type(self.changes['+++'][key]) == list:
if type(device_current[key]) != list:
device_current[key] = []
for item in self.changes['+++'][key]:
device_current[key].append(item)
else:
device_current[key] = self.changes['+++'][key]
return device_current
# try:
# self._device_mng.verify_device_accessible(retries=2)
# except RadwareError as e:
# raise RadwareModuleError(e)
try:
conf_mng_result = self._config_manager.execute(
self._configurator,
self.command,
self.arguments,
dry_run=self._base.module.check_mode,
differential=self._differential_update,
write_on_change=self._write_on_change,
get_diff=True)
if conf_mng_result.diff:
self.changed = True
self.changes = conf_mng_result.diff
except RadwareError as e:
self._on_error()
raise RadwareModuleError(e)
if self.changed:
self.result.update(dict(changed=self.changed))
if self._report_diff:
self.result.update(dict(diff=self.changes))
self.result.update(status=conf_mng_result.content_translate,
obj=prepare_object())
else:
if self._state in ANSIBLE_TO_SDK_CMD:
self.result.update(status=MSG_NO_CHANGE, obj=None)
else:
if self._state == 'read':
read_result = conf_mng_result.content_translate
if read_result:
self.result.update(status='found', obj=read_result)
else:
self.result.update(status='not found', obj=read_result)
else:
self.result.update(
status=conf_mng_result.content_translate, obj=None)
return self.result