def v2_runner_on_unreachable(self, res):
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=res._task.get_name())
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.ERROR_UNREACHABLE.format(
res._task.get_name()))
def v2_runner_on_ok(self, res):
self.update_task_state(new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=res._task.get_name())
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.PLAYBOOK_TASK_OK.format(
res._task.get_name()))
def probe_device_not_alive(self, device, timeout):
"""
:param device:
:param timeout:
:return:
"""
alive = device.deviceConnection.probe(timeout=5)
probe_attemps = self.grp_cfg.TASKS.Provision.Software.RebootProbeCounter
probe_cntr = 0
while alive:
if probe_cntr <= probe_attemps:
alive = device.deviceConnection.probe(1)
probe_cntr += 1
Tools.emit_log(task_name=self.task_name,
sample_device=device,
message=logmsg.SW_PROBE_DEV.format(timeout))
self.update_task_state(
new_task_state=c.TASK_STATE_REBOOTING,
task_state_message=logmsg.SW_PROBE_WAIT_REBOOT.format(
str(probe_cntr)))
time.sleep(timeout)
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.TASK_STATE_MSG_FAILED)
break
return alive
def v2_runner_on_failed(self, res, ignore_errors=False):
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=res._task.get_name())
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.PLAYBOOK_ERROR.format(
res._task.get_name()))
return
def dep_configuration_ipam(self):
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=
'Processing configuration task deps for ipam task')
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message='Processing configuration task deps for ipam task')
self.sample_device.deviceConfigData['ipam'] = dict()
for idx, ip in enumerate(self.shared[c.TASK_SHARED_IPAM]):
self.sample_device.deviceConfigData['ipam']['IP' +
str(idx)] = ip[0]
def run_task(self):
if self.sample_device.deviceConnection is not None:
self.update_task_state(new_task_state=c.TASK_STATE_DONE, task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
task_state={'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE},
sample_device=self.sample_device, grp_cfg=self.grp_cfg,
shared=self.shared, message=c.TASK_STATE_MSG_DONE,
scope=c.LOGGER_SCOPE_ALL, level=c.LOGGER_LEVEL_INFO)
else:
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.INIT_DEV_CONN_NOK.format(self.sample_device.deviceIP))
Tools.emit_log(task_name=self.task_name, sample_device=self.sample_device,
message=logmsg.INIT_DEV_CONN_NOK.format(self.sample_device.deviceIP))
def run_task(self):
self.logger.info(
Tools.create_log_msg(
self.task_name, self.sample_device.deviceSerial,
logmsg.CLEANUP_CLOSE_CONN.format(
hex(id(self.sample_device.deviceConnection)))))
try:
self.sample_device.deviceConnection.close()
self.logger.info(
Tools.create_log_msg(
self.task_name, self.sample_device.deviceSerial,
logmsg.CLEANUP_CLOSE_CONN_SUCCESS.format(
hex(id(self.sample_device.deviceConnection)))))
except TimeoutExpiredError:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message='Connection timeout error')
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message='Connection timeout error')
return
self.update_task_state(new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=c.TASK_STATE_MSG_DONE,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
def run_task(self):
if self.grp_cfg.TASKS.Provision.Discovery.Mode == 'Discovery':
resp = c.SRC.discover_by_space(sample_device=self.sample_device, shared=self.shared)
if resp == c.TASK_STATE_DONE:
self.update_task_state(new_task_state=c.TASK_STATE_DONE, task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
task_state={'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE},
sample_device=self.sample_device, grp_cfg=self.grp_cfg,
shared=self.shared, message=c.TASK_STATE_MSG_DONE,
scope=c.LOGGER_SCOPE_ALL, level=c.LOGGER_LEVEL_INFO)
elif resp == c.TASK_STATE_FAILED:
self.update_task_state(new_task_state=c.TASK_STATE_FAILED, task_state_message=c.TASK_STATE_MSG_FAILED)
Tools.emit_log(task_name=self.task_name, sample_device=self.sample_device,
message=c.TASK_STATE_MSG_FAILED)
elif self.grp_cfg.TASKS.Provision.Discovery.Mode == 'Configlet':
resp = c.SRC.discover_by_configlet(sample_device=self.sample_device, shared=self.shared)
if resp == c.TASK_STATE_DONE:
self.update_task_state(new_task_state=c.TASK_STATE_DONE, task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
task_state={'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE},
sample_device=self.sample_device, grp_cfg=self.grp_cfg,
shared=self.shared, message=c.TASK_STATE_MSG_DONE,
scope=c.LOGGER_SCOPE_ALL, level=c.LOGGER_LEVEL_INFO)
elif resp == c.TASK_STATE_FAILED:
self.update_task_state(new_task_state=c.TASK_STATE_FAILED, task_state_message=c.TASK_STATE_MSG_FAILED)
Tools.emit_log(task_name=self.task_name, sample_device=self.sample_device,
message=c.TASK_STATE_MSG_FAILED)
else:
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.DISCOVERY_MODE_NOK.format(
self.grp_cfg.TASKS.Provision.Discovery.Mode))
Tools.emit_log(task_name=self.task_name, sample_device=self.sample_device,
message=logmsg.DISCOVERY_MODE_NOK.format(self.grp_cfg.TASKS.Provision.Discovery.Mode))
def __init__(self, sample_device=None, shared=None):
self.logger = c.logger
self.task_state = c.TASK_STATE_INIT
self.task_progress = 0.0
self.messages = {
'error': 'error',
'valid': 'valid',
'invalid': 'invalid',
'deactivated': 'deactivated'
}
self.task_name = self.__class__.__name__.split('Task')[0]
self.sample_device = sample_device
self.shared = shared
self.grp_cfg = Tools.create_config_view(
c.CONFIG_TYPE_GROUP, stream=sample_device.deviceGroupData)
self.task_type = self.__class__.TASK_TYPE
self.check_schema = self.__class__.CHECK_SCHEMA
self.task_version = self.__class__.TASK_VERSION
self._backendp = BackendClientProcessor(
exchange='', routing_key=c.AMQP_RPC_BACKEND_QUEUE)
self.logger.info(
Tools.create_log_msg(self.task_name,
self.sample_device.deviceSerial,
'Validating task configuration'))
isValid, err = self.__validate_task_config(
grp_cfg=sample_device.deviceGroupData)
if isValid == self.messages['valid']:
self.logger.info(
Tools.create_log_msg(self.task_name,
self.sample_device.deviceSerial,
'Task configuration is valid'))
# self.pre_run_task()
# self.run_task()
# self.post_run_task()
elif isValid == self.messages['invalid']:
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message='Task configuration is invalid. <{0}>'.format(err))
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.TASK_STATE_MSG_FAILED)
return
elif isValid == self.messages['error']:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message='Task configuration file not found')
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.TASK_STATE_MSG_FAILED)
return
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message='Task configuration validation deactivated')
def run_task(self):
# this task has to run some when after configuration task
# Spin up VNFs
# Done
datavars = self.sample_device.deviceConfigData
if datavars:
for vnf in datavars['device']['vnfs']:
self.logger.info(
Tools.create_log_msg(
self.task_name, self.sample_device.deviceSerial,
logmsg.VNFSPIN_INIT.format(vnf['name'])))
req1 = '{0} {1}'.format(
'request virtual-network-functions start', vnf['name'])
self.sample_device.deviceConnection.cli(command=req1,
format='text',
warning=False)
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.VNFSPIN_VNF_OK.format(
vnf['name']))
Tools.emit_log(task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.VNFSPIN_VNF_OK.format(
vnf['name']),
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
else:
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.VNFSPIN_FILE_ERR)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.VNFSPIN_FILE_ERR)
return
self.update_task_state(new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=c.TASK_STATE_DONE)
def run_task(self):
if self.sample_device.deviceConnection.connected:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message='Processing task dependencies: {0}'.format(
self.grp_cfg.TASKS.Provision.Init.Dependencies))
if self.grp_cfg.TASKS.Provision.Init.Dependencies:
module = Tools.get_task_module_from_group(
grp_cfg=self.grp_cfg, task_name='Configuration')
if module == 'Internal':
for dep in self.grp_cfg.TASKS.Provision.Init.Dependencies:
if dep in self.grp_cfg.TASKS.Sequence:
task_dep = getattr(
self, 'dep_init_{0}'.format(dep.lower()))
task_dep()
self.update_task_state(new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
task_state=self.sample_device.deviceTasks.taskState[
self.task_name],
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=c.TASK_STATE_MSG_DONE,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.INIT_DEV_CONN_NOK.format(
self.sample_device.deviceSerial))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.INIT_DEV_CONN_NOK.format(
self.sample_device.deviceSerial))
def get_software_image_name(cls, sample_device, target_version, grp_cfg):
"""
read file names stored under local images directory, extract label and compare them with target images version
- return local filename if we have
- return False if we don't
:param sample_device:
:param target_version:
:param grp_cfg:
:return: filename or False
"""
Tools.emit_log(task_name='SOFTWARE',
sample_device=sample_device,
message=logmsg.SW_CHECK_DIR.format(target_version))
f = False
for filename in os.listdir(grp_cfg.TASKS.Provision.Software.ImageDir):
if filename.endswith(".tgz"):
local_version = re.findall(r"(?:[\d.X]+)(?:\-*)(?:[D\d.]+)",
filename)[0]
if target_version == local_version:
Tools.emit_log(
task_name='SOFTWARE',
sample_device=sample_device,
message=logmsg.SW_IMAGE_OK.format(local_version))
f = filename
break
else:
pass
if not f:
# if no file found, return False
Tools.emit_log(task_name='SOFTWARE',
sample_device=sample_device,
message=logmsg.SW_IMAGE_NOK.format(target_version))
return f
def get_software_image_name(cls, sample_device, target_version, grp_cfg):
"""
read file names stored under local images directory, extract label and compare them with target images version
- return local filename if we have
- return False if we don't
:param sample_device:
:param target_version:
:param grp_cfg:
:return: filename or False
"""
Tools.emit_log(task_name='SOFTWARE', sample_device=sample_device,
message=logmsg.SW_CHECK_DIR.format(target_version))
_filename = Path("{0}/{1}.tgz".format(grp_cfg.TASKS.Provision.Software.ImageDir, target_version))
if _filename.is_file():
Tools.emit_log(task_name='SOFTWARE', sample_device=sample_device,
message=logmsg.SW_IMAGE_OK.format(target_version))
return "{0}.tgz".format(target_version)
else:
Tools.emit_log(task_name='SOFTWARE', sample_device=sample_device,
message=logmsg.SW_IMAGE_NOK.format(target_version))
return False
def install_device_software(self, path, image, target_version):
"""
Call PyEz to install new JUNOS image to device
:param sample_device:
:param path:
:param image:
:return:
"""
package = os.path.join(os.getcwd(), path)
if c.SERVICEPLUGIN_OSSH in self.sample_device.deviceServicePlugin:
try:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_CLEANUP_STORAGE)
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_CLEANUP_STORAGE)
self.sample_device.deviceConnection.rpc.request_system_storage_cleanup(
)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_COPY_IMG.format(image))
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_COPY_IMG.format(image))
# progress = SoftwareTask.copy_progress
with SCPClient(transport=self.sample_device.deviceConnection.
_conn._session.transport) as scp:
scp.put(package,
remote_path=self.grp_cfg.TASKS.Provision.Software.
RemoteDir)
except (BadHostKeyException, AuthenticationException) as e:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_COPY_IMG_NOK.format(
e.message))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_COPY_IMG_NOK.format(
e.message))
return self.sample_device
try:
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALL_VERS.format(target_version))
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_INSTALL_VERS.format(
target_version))
result = self.sample_device.deviceConnection.sw.pkgadd(
self.grp_cfg.TASKS.Provision.Software.RemoteDir + image,
dev_timeout=self.grp_cfg.TASKS.Provision.Software.
PkgAddDevTimeout)
except Exception as err:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALL_NOK.format(str(err)))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_INSTALL_NOK.format(str(err)))
return self.sample_device
if result is True:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALL_OK.format(
self.sample_device.deviceIP))
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_INSTALL_OK.format(
self.sample_device.deviceIP))
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALL_NOK.format(
str(result)))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_INSTALL_NOK.format(
str(result)))
time.sleep(3)
return self.sample_device
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_REBOOT.format(
self.sample_device.deviceIP))
self.update_task_state(new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_REBOOT.format(
self.sample_device.deviceIP))
try:
rsp = self.sample_device.deviceConnection.sw.reboot()
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_REBOOT_DEV_RESP.format(
rsp.replace('\n', " ")))
self.sample_device.deviceConnection.close()
self.sample_device.deviceIsRebooted = True
self.update_task_state(new_task_state=c.TASK_STATE_REBOOTING,
task_state_message='Rebooting...')
c.oss_seen_devices_lck.acquire()
try:
if self.sample_device.deviceIP in c.oss_seen_devices:
c.oss_seen_devices.pop(self.sample_device.deviceIP,
None)
finally:
c.oss_seen_devices_lck.release()
return self.sample_device
except exception.ConnectClosedError:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_CONN_LOOSE_REBOOT)
self.update_task_state(
new_task_state=c.TASK_STATE_REBOOTING,
task_state_message=logmsg.SW_CONN_LOOSE_REBOOT)
return self.sample_device
else:
try:
result = self.sample_device.deviceConnection.sw.install(
package=package,
remote_path=self.grp_cfg.TASKS.Provision.Software.
RemoteDir,
cleanfs=True,
no_copy=False,
progress=SoftwareTask.install_progress)
except Exception as err:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALL_NOK.format(str(err)))
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=str(err))
return self.sample_device
if result is True:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALL_OK.format(
self.sample_device.deviceIP))
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_INSTALL_OK.format(
self.sample_device.deviceIP))
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALL_NOK.format(
str(result)))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_INSTALL_NOK.format(
str(result)))
time.sleep(3)
return self.sample_device
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_REBOOT.format(
self.sample_device.deviceIP))
self.update_task_state(new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_REBOOT.format(
self.sample_device.deviceIP))
try:
rsp = self.sample_device.deviceConnection.sw.reboot()
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_REBOOT_DEV_RESP.format(
rsp.replace('\n', " ")))
# self.sample_device.deviceConnection.close()
except exception.ConnectClosedError:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_CONN_LOOSE_REBOOT)
self.update_task_state(
new_task_state=c.TASK_STATE_REBOOTING,
task_state_message=logmsg.SW_CONN_LOOSE_REBOOT)
finally:
alive = self.probe_device_not_alive(
self.sample_device,
self.grp_cfg.TASKS.Provision.Software.RetryProbeCounter)
if not alive:
self.sample_device.deviceIsRebooted = True
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_PROBE_WAKEUP.format(
self.sample_device.deviceIP))
status, self.sample_device = Tools.create_dev_conn(
self.sample_device, connect=False)
if status:
alive = self.probe_device_alive(
self.sample_device, self.grp_cfg.TASKS.Provision.
Software.RebootProbeTimeout)
if alive:
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_PROBE_WAKUP_OK.format(
self.sample_device.deviceIP))
self.sample_device.deviceIsRebooted = False
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_PROBE_WAKUP_OK.
format(self.sample_device.deviceIP))
status, self.sample_device = Tools.create_dev_conn(
self.sample_device)
if status:
self.sample_device.deviceConnection.bind(
cu=Config, sw=SW)
# Tools.emit_log(task_name=self.task_name, sample_device=self.sample_device,
# message=logmsg.SW_CONN_OK.format(self.sample_device.deviceIP))
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.SW_CONN_OK.
format(self.sample_device.deviceIP))
return self.sample_device
else:
return self.sample_device
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.TASK_STATE_MSG_FAILED)
self.sample_device.deviceConnection = None
return self.sample_device
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_PROBE_DEV_NOK.format(
self.sample_device.deviceIP,
self.grp_cfg.TASKS.Provision.Software.
RebootProbeCounter))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_PROBE_DEV_NOK.format(
self.sample_device.deviceIP, self.grp_cfg.TASKS.
Provision.Software.RebootProbeCounter))
def run_task(self):
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CLEANUP_CLOSE_CONN.format(
hex(id(self.sample_device.deviceConnection))))
if isinstance(self.sample_device.deviceConnection, NetworkDriver):
self.sample_device.deviceConnection.close()
else:
if c.SERVICEPLUGIN_OSSH in self.sample_device.deviceServicePlugin:
try:
self.sample_device.deviceConnection.cli('op cleanup',
warning=False)
except ConnectClosedError as cce:
pass
c.oss_seen_devices_lck.acquire()
try:
if self.sample_device.deviceIP in c.oss_seen_devices:
c.oss_seen_devices.pop(self.sample_device.deviceIP,
None)
finally:
c.oss_seen_devices_lck.release()
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(
task_name=self.task_name,
task_state=self.sample_device.deviceTasks.taskState[
self.task_name],
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.CLEANUP_CLOSE_CONN_SUCCESS.format(
hex(id(self.sample_device.deviceConnection))),
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
else:
if self.sample_device.deviceConnection.connected:
try:
self.sample_device.deviceConnection.close()
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(
task_name=self.task_name,
task_state=self.sample_device.deviceTasks.
taskState[self.task_name],
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.CLEANUP_CLOSE_CONN_SUCCESS.format(
hex(id(self.sample_device.deviceConnection))),
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
except TimeoutExpiredError:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.
CLEANUP_CLOSE_CONN_TIMEOUT)
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CLEANUP_CLOSE_CONN_TIMEOUT)
return
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CLEANUP_CLOSE_CONN_ERROR.
format(hex(id(self.sample_device.deviceConnection))))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CLEANUP_CLOSE_CONN_ERROR.format(
hex(id(self.sample_device.deviceConnection))))
return
def run_task(self):
status_dev_cfg, dev_data_file = Tools.get_config(
lookup_type=c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG_FILE,
sample_device=self.sample_device)
status_template, template_file = Tools.get_config(
lookup_type=c.CONFIG_LOOKUP_TYPE_GET_TEMPLATE_FILE,
sample_device=self.sample_device)
if status_dev_cfg:
if status_template:
loader = DataLoader()
try:
ds = loader.load_from_file(
os.getcwd() + '/' + self.grp_cfg.TASKS.Provision.
Configuration.Ansibleapi.PlaybookPath + self.grp_cfg.
TASKS.Provision.Configuration.Ansibleapi.Playbook)
except AnsibleFileNotFound as afnf:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.PLAYBOOK_NOT_FOUND.format(
afnf))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.PLAYBOOK_NOT_FOUND.format(afnf))
return
# Dynamic Inventory
inventory = """
[YAPT]
{{ hosts }}
[YAPT:vars]
junos_user={{ junos_user }}
junos_password={{ junos_password }}
template_src={{ template_src }}
template_dst={{ template_dst }}
device_vars={{ device_vars }}
heading={{ heading }}
"""
inventory_template = jinja2.Template(inventory)
'''
## Last changed: 2017-10-16-2139 version 12.1X47-D35.2;
'''
heading = """## Last changed: {0} version {1};
""".format(
datetime.datetime.now().strftime('%Y-%m-%d-%H%M'),
self.sample_device.softwareVersion)
rendered_inventory = inventory_template.render({
'hosts':
self.sample_device.deviceIP,
'junos_user':
c.conf.YAPT.DeviceUsr,
'junos_password':
Tools.get_password(c.YAPT_PASSWORD_TYPE_DEVICE),
'template_src':
template_file,
'template_dst':
os.getcwd() + '/history/' +
self.sample_device.deviceSerial + '-' +
datetime.datetime.now().strftime('%Y-%m-%d-%H%M') +
'.conf',
'device_vars':
dev_data_file,
'heading':
heading
})
self.logger.debug(
Tools.create_log_msg(self.task_name,
self.sample_device.deviceSerial,
rendered_inventory))
# Create a temporary file and write the template string to it
hosts = NamedTemporaryFile(delete=False)
hosts.write(rendered_inventory)
hosts.close()
inventory = InventoryManager(loader=loader, sources=hosts.name)
variable_manager = VariableManager(loader=loader,
inventory=inventory)
Options = namedtuple('Options', [
'listtags', 'listtasks', 'listhosts', 'syntax',
'connection', 'module_path', 'forks', 'remote_user',
'private_key_file', 'ssh_common_args', 'ssh_extra_args',
'sftp_extra_args', 'scp_extra_args', 'become',
'become_method', 'become_user', 'verbosity', 'check',
'diff'
])
options = Options(listtags=False,
listtasks=False,
listhosts=True,
syntax=False,
connection='ssh',
module_path=None,
forks=100,
remote_user=None,
private_key_file=None,
ssh_common_args=None,
ssh_extra_args=None,
sftp_extra_args=None,
scp_extra_args=None,
become=False,
become_method=None,
become_user=None,
verbosity=None,
check=False,
diff=False)
passwords = dict(
vault_pass=Tools.get_password(c.YAPT_PASSWORD_TYPE_DEVICE))
play = Play.load(data=ds[0],
variable_manager=variable_manager,
loader=loader)
results_callback = CallbackModule(
sample_device=self.sample_device,
shared=self.shared,
update_task_state=self.update_task_state)
tqm = None
try:
tqm = TaskQueueManager(
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords,
stdout_callback=results_callback,
)
result = tqm.run(play)
if result > 0:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.ANSIBLE_ERROR)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.ANSIBLE_ERROR)
os.remove(hosts.name)
return
else:
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.PLAYBOOK_FINISHED_SUCCESS
)
self.sample_device.deviceConnection.facts_refresh()
self.sample_device.deviceConnection.facts_refresh(
keys='hostname')
self.sample_device.deviceName = self.sample_device.deviceConnection.facts[
'hostname']
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(
task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.PLAYBOOK_FINISHED_SUCCESS,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
os.remove(hosts.name)
except Exception as e:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.PLAYBOOK_ERROR.format(e))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.PLAYBOOK_ERROR.format(e))
return
finally:
if tqm is not None:
tqm.cleanup()
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.ERROR_DEV_CFG_FILE)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.ERROR_DEV_TEMPLATE_FILE.format(
template_file))
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.ERROR_DEV_CFG_FILE)
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.ERROR_DEV_CFG_FILE.format(dev_data_file))
return
def run_task(self):
a = AuthOptions({'authoritative_source': 'yapt'})
pynipap.xmlrpc_uri = "http://{0}:{1}@{2}:{3}/XMLRPC".format(
self.grp_cfg.TASKS.Provision.Ipam.User,
self.grp_cfg.TASKS.Provision.Ipam.Password,
self.grp_cfg.TASKS.Provision.Ipam.Address,
self.grp_cfg.TASKS.Provision.Ipam.Port)
for prefix in self.grp_cfg.TASKS.Provision.Ipam.Prefixes:
try:
p = Prefix.find_free(None, {
'from-prefix': [prefix],
'prefix_length': 32
})
except socket.error as se:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.IPAM_CONN_ERR.format(
se.strerror))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.IPAM_CONN_ERR.format(
se.strerror))
return
except NipapAuthenticationError as nae:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.IPAM_CONN_ERR.format(
nae.message))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.IPAM_CONN_ERR.format(
nae.message))
return
if p:
self.shared[c.TASK_SHARED_IPAM].append(p)
new_prefix = Prefix()
new_prefix.prefix = p[0]
new_prefix.type = 'host'
new_prefix.description = self.sample_device.deviceSerial
try:
new_prefix.save()
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(
task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO,
message=logmsg.IPAM_PREFIX_OK.format(prefix))
except NipapValueError as nve:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.IPAM_PREFIX_ERR.format(
nve.message))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.IPAM_PREFIX_ERR.format(
nve.message))
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.IPAM_PREFIX_FULL.format(prefix))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.IPAM_PREFIX_FULL.format(prefix))
def do_cert_requests(self, datavars=None, event=None, cancel_chan=None):
# Do time sync before getting certs
req0 = 'set date ntp {0}'.format(datavars['device']['ntp_server'])
req1 = 'request security pki ca-certificate enroll ca-profile ' + datavars[
'device']['cert']['ca_profile']
req2 = 'request security pki ca-certificate verify ca-profile ' + datavars[
'device']['cert']['ca_profile']
req3 = 'request security pki generate-key-pair certificate-id ' + datavars['device']['hostname'] \
+ ' size 2048 type rsa'
req4 = 'request security pki local-certificate enroll ca-profile ' + datavars['device']['cert'][
'ca_profile'] \
+ ' certificate-id ' + datavars['device']['hostname'] + ' domain-name ' + \
datavars['device']['cert']['domain_name'] \
+ ' subject ' + datavars['device']['cert']['subject'] + ' challenge-password ' \
+ datavars['device']['cert']['challenge_password']
pattern = r'(error):\s.*'
regex = re.compile(pattern, re.MULTILINE)
if event is not None:
event.wait()
self.update_task_state(new_task_state=c.TASK_STATE_PROGRESS,
task_state_message='Request Time Sync')
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD.format(req0))
resp = self.sample_device.deviceConnection.cli(command=req0,
format='text',
warning=False)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD_RESP.format(req0, resp))
try:
self.update_task_state(new_task_state=c.TASK_STATE_PROGRESS,
task_state_message='Request CA Cert')
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD.format(req1))
resp = self.sample_device.deviceConnection.cli(command=req1,
format='text',
warning=False)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD_RESP.format(
req1, resp))
status = re.findall(regex, resp)
if len(status) > 0 and status[0] == 'error':
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=resp)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=resp)
return
else:
self.update_task_state(new_task_state=c.TASK_STATE_PROGRESS,
task_state_message='Verify CA Cert')
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD.format(req2))
resp = self.sample_device.deviceConnection.cli(command=req2,
format='text',
warning=False)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD_RESP.format(
req2, resp))
status = re.findall(regex, resp)
if len(status) > 0 and status[0] == 'error':
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=status)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=status)
return
else:
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message='Generate local keys')
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD.format(req3))
resp = self.sample_device.deviceConnection.cli(
command=req3, format='text', warning=False)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD_RESP.format(
req3, resp))
status = re.findall(regex, resp)
if len(status) > 0 and status[0] == 'error':
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=status)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=status)
return
else:
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message='Request local cert')
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD.format(req4))
resp = self.sample_device.deviceConnection.cli(
command=req4, format='text', warning=False)
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CERT_ISSUE_CMD_RESP.format(
req4, resp))
status = re.findall(regex, resp)
if len(status) > 0 and status[0] == 'error':
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=status)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=status)
return
else:
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
task_state={
'taskState':
self.task_state,
'taskStateMsg':
c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=c.TASK_STATE_MSG_DONE,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
time.sleep(5)
if cancel_chan is not None:
cancel_chan.cancel()
except (RPCError, TimeoutExpiredError) as err:
self.logger.info(
Tools.create_log_msg(
self.task_name, self.sample_device.deviceSerial,
logmsg.CERT_ISSUE_CMD_NOK.format(req0, err.message)))
self.sample_device.deviceTasks.taskState[
self.task_name] = err.message
def update_task_state(self,
new_task_state=c.TASK_STATE_INIT,
task_state_message='empty'):
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message='Current task state <{0}> --> New task state <{1}>'.format(
self.task_state, new_task_state),
level=c.LOGGER_LEVEL_DEBUG)
if getattr(self, 'TASK_DESCENT', None):
task_name = self.TASK_DESCENT
else:
task_name = self.task_name
if new_task_state == c.TASK_STATE_DONE:
if task_name == self.grp_cfg.TASKS.Sequence[-1:][0]:
self.task_state = new_task_state
self.sample_device.deviceStatus = c.DEVICE_STATUS_DONE
self.task_progress = self.shared[c.TASK_SHARED_PROGRESS]
self._update_backend()
self.sample_device.deviceTasks.taskState[task_name] = {
'taskState': new_task_state,
'taskStateMsg': task_state_message
}
else:
self.task_state = new_task_state
self.sample_device.deviceStatus = c.DEVICE_STATUS_NEXT_TASK
self.task_progress = self.shared[c.TASK_SHARED_PROGRESS]
self._update_backend()
self.sample_device.deviceTasks.taskState[task_name] = {
'taskState': new_task_state,
'taskStateMsg': task_state_message
}
elif new_task_state == c.TASK_STATE_FAILED:
self.task_state = new_task_state
self.sample_device.deviceStatus = c.DEVICE_STATUS_FAILED
self._update_backend()
self.sample_device.deviceTasks.taskState[task_name] = {
'taskState': new_task_state,
'taskStateMsg': task_state_message
}
elif new_task_state == c.TASK_STATE_REBOOTING:
self.task_state = new_task_state
self.sample_device.deviceStatus = c.DEVICE_STATUS_REBOOTED
self._update_backend()
self.sample_device.deviceTasks.taskState[task_name] = {
'taskState': new_task_state,
'taskStateMsg': task_state_message
}
elif new_task_state == c.TASK_STATE_PROGRESS:
self.task_state = new_task_state
self.sample_device.deviceStatus = c.DEVICE_STATUS_PROGRESS
self._update_backend()
self.sample_device.deviceTasks.taskState[task_name] = {
'taskState': new_task_state,
'taskStateMsg': task_state_message
}
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message='Unknown task state <{0}>'.format(
self.task_state))
def run_task(self):
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CP_INIT.format(
self.grp_cfg.TASKS.Provision.Filecp.Files))
if self.sample_device.deviceConnection.connected:
try:
if c.SERVICEPLUGIN_OSSH == self.sample_device.deviceServicePlugin:
with SCPClient(self.sample_device.deviceConnection._conn.
_session.transport) as scp:
for _file in self.grp_cfg.TASKS.Provision.Filecp.Files:
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CP_COPY.format(
_file))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CP_COPY.format(_file))
scp.put(
self.grp_cfg.TASKS.Provision.Filecp.
FileLocalDir + _file, self.grp_cfg.TASKS.
Provision.Filecp.FileRemoteDir)
Tools.emit_log(
task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.CP_SUCCESS.format(_file),
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
else:
with SCP(self.sample_device.deviceConnection,
progress=False) as scp:
for _file in self.grp_cfg.TASKS.Provision.Filecp.Files:
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CP_COPY.format(
_file))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CP_COPY.format(_file))
scp.put(
self.grp_cfg.TASKS.Provision.Filecp.
FileLocalDir + _file, self.grp_cfg.TASKS.
Provision.Filecp.FileRemoteDir)
Tools.emit_log(
task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.CP_SUCCESS.format(_file),
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
except (paramiko.BadHostKeyException,
paramiko.AuthenticationException) as e:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CP_FAILED.format(e.message))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CP_FAILED.format(e.message))
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CP_FAILED_NO_CONN)
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CP_FAILED_NO_CONN)
def run_task(self):
"""
Provision device config
:param sample_device: A device object for which the config provisioning should be done
:return:
"""
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_INIT.format(
self.sample_device.deviceSerial))
configurator = Configuration()
resp = configurator.prepare_device_config(
sample_device=self.sample_device)
if resp['status']:
self._device_config_file = resp['configfilename']
if self.sample_device.deviceConnection.connected:
# Lock the configuration, load configuration changes, and commit
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_LOCK)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_LOCK)
try:
self.sample_device.deviceConnection.cu.lock()
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_LOCK_OK)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_LOCK_OK)
except LockError as err:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CONF_TASK_LOCK_NOK.format(
err.message))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_LOCK_NOK.format(
err.message))
return
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_LOAD)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_LOAD)
try:
self.sample_device.deviceConnection.cu.load(
path=self.grp_cfg.TASKS.Provision.Configuration.
ConfigFileHistory + self._device_config_file,
merge=self.grp_cfg.TASKS.Provision.Configuration.Merge,
overwrite=self.grp_cfg.TASKS.Provision.Configuration.
Overwrite)
except (ConfigLoadError, ValueError, Exception) as err:
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_LOAD_NOK.format(err))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CONF_TASK_LOAD_NOK.format(
err))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_UNLOCK)
try:
self.sample_device.deviceConnection.cu.unlock()
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_UNLOCK_OK)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_UNLOCK_OK)
except UnlockError:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CONF_TASK_UNLOCK_NOK.
format(err))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_UNLOCK_NOK.format(err))
return
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_COMMIT)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_COMMIT)
try:
self.sample_device.deviceConnection.cu.commit(
timeout=self.grp_cfg.TASKS.Provision.Configuration.
Internal.CommitTimeout,
comment='Commit by YAPT at {0}'.format(
datetime.datetime.now().strftime('%Y-%m-%d-%H%M')),
confirm=int(self.grp_cfg.TASKS.Provision.Configuration.
Internal.ConfirmedTimeout))
self.sample_device.deviceConnection.cu.commit(
timeout=self.grp_cfg.TASKS.Provision.Configuration.
Internal.CommitTimeout,
comment='Commit confirmed by YAPT at {0}'.format(
datetime.datetime.now().strftime('%Y-%m-%d-%H%M')))
if not self.sample_device.deviceModel.startswith('NFX'):
self.sample_device.deviceConnection.cu.rescue('save')
except (CommitError, ConnectClosedError, RpcTimeoutError,
TimeoutExpiredError) as err:
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_COMMIT_NOK.format(
err.message))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_COMMIT_NOK.format(
err.message))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_UNLOCK)
try:
self.sample_device.deviceConnection.cu.unlock()
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.TASK_STATE_MSG_FAILED)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_UNLOCK_OK)
except (UnlockError, ConnectClosedError) as err:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.TASK_STATE_MSG_FAILED)
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_UNLOCK_NOK.format(
err.message))
return
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_UNLOCK)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_UNLOCK)
try:
self.sample_device.deviceConnection.cu.unlock()
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_UNLOCK_OK)
self.logger.info(
Tools.create_log_msg(self.task_name,
self.sample_device.deviceSerial,
logmsg.CONF_TASK_UNLOCK_OK))
except UnlockError as err:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CONF_TASK_UNLOCK_NOK.format(
err.message))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_UNLOCK_NOK.format(
err.message))
return
# If refreshing facts on NFX it needs more time doing so after configuration commit
if self.sample_device.deviceModel.startswith('NFX'):
time.sleep(15)
self.sample_device.deviceConnection.facts_refresh(
keys='hostname')
self.sample_device.deviceName = self.sample_device.deviceConnection.facts[
'hostname']
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.CONF_TASK_COMMIT_OK.format(
self._device_config_file),
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CONF_TASK_CONN_NOK.format(
self.sample_device.deviceSerial))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_CONN_NOK.format(
self.sample_device.deviceSerial))
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CONF_TASK_CFG_TEMPLATE_ERROR.format(
'', '', resp['configfilename']))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_CFG_TEMPLATE_ERROR.format(
'', '', resp['configfilename']))
def run_sum_mode(self):
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.TICKET_INIT.format(
self.sample_device.deviceSerial,
self.grp_cfg.TASKS.Provision.Ticket.Mode))
url = '{0}://{1}:{2}/login'.format(
self.grp_cfg.TASKS.Provision.Ticket.Protocol,
self.grp_cfg.TASKS.Provision.Ticket.Address,
self.grp_cfg.TASKS.Provision.Ticket.Port)
session = requests.Session()
data = {
'username': "******".format(self.grp_cfg.TASKS.Provision.Ticket.User),
'password':
"******".format(self.grp_cfg.TASKS.Provision.Ticket.Password),
'eauth': "{0}".format(self.grp_cfg.TASKS.Provision.Ticket.Eauth),
}
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.TICKET_CONN_INIT.format(url))
resp = None
try:
resp = session.post(url, json=data, verify=False)
except ConnectionError as cer:
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.TASK_STATE_MSG_FAILED)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=cer.message)
if resp is not None:
if resp.status_code == 200:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.TICKET_CONN_OK.format(url))
try:
env = Environment(
autoescape=False,
loader=FileSystemLoader(
self.grp_cfg.TASKS.Provision.Ticket.TemplateDir),
trim_blocks=True,
lstrip_blocks=True)
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message='Found template <{0}>)'.format(
self.grp_cfg.TASKS.Provision.Ticket.
TicketCreateTemplate))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message='Found template directory <{0}>'.format(
self.grp_cfg.TASKS.Provision.Ticket.TemplateDir))
except TemplateNotFound as err:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=
'Error in getting template directory <{0}>'.format(
err.message))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message='Error in getting template directory <{0}>'.
format(err.message))
return
try:
template = env.get_template(self.grp_cfg.TASKS.Provision.
Ticket.TicketCreateTemplate)
tasks = collections.OrderedDict()
for task in self.grp_cfg.TASKS.Sequence:
tasks[task] = self.sample_device.deviceTasks.taskState[
task]
ticket_created = template.render(
deviceSerial=self.sample_device.deviceSerial,
deviceName=self.sample_device.deviceName,
deviceModel=self.sample_device.deviceModel,
deviceGroup=self.sample_device.deviceGroup,
deviceStatus=self.sample_device.deviceStatus,
lastSeen=self.sample_device.deviceTimeStamp,
tasks=tasks)
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=
'Successfully rendered template <{0}>'.format(
self.grp_cfg.TASKS.Provision.Ticket.
TicketCreateTemplate))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message='Successfully rendered template <{0}>'.format(
self.grp_cfg.TASKS.Provision.Ticket.
TicketCreateTemplate))
except TemplateNotFound as err:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=
'Error in getting template file <{0}{1}>'.format(
self.grp_cfg.TASKS.Provision.Ticket.TemplateDir,
err.message))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message='Error in getting template file <{0}{1}>'.
format(self.grp_cfg.TASKS.Provision.Ticket.TemplateDir,
err.message))
return
data = {
"client":
"runner",
"fun":
"{0}".format(
self.grp_cfg.TASKS.Provision.Ticket.Functions[0]),
"subject":
"YAPT new provisioning device <{0}>".format(
self.sample_device.deviceSerial),
"text":
ticket_created,
"next_event":
"{0}".format(
self.grp_cfg.TASKS.Provision.Ticket.NextEvent),
"data":
dict()
}
url = '{0}://{1}:{2}/'.format(
self.grp_cfg.TASKS.Provision.Ticket.Protocol,
self.grp_cfg.TASKS.Provision.Ticket.Address,
self.grp_cfg.TASKS.Provision.Ticket.Port)
resp = None
try:
resp = session.post(url, json=data, verify=False)
except ConnectionError as cer:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.TASK_STATE_MSG_FAILED)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=cer.message)
if resp is not None:
if resp.status_code == 200:
data = resp.json()
self.shared[c.TASK_SHARED_TICKET] = data['return'][0][
'ticket_id']
url = '{0}://{1}:{2}/logout'.format(
self.grp_cfg.TASKS.Provision.Ticket.Protocol,
self.grp_cfg.TASKS.Provision.Ticket.Address,
self.grp_cfg.TASKS.Provision.Ticket.Port)
resp = session.post(url, verify=False)
if resp.status_code == 200:
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(
task_name=self.task_name,
task_state={
self.task_name:
self.sample_device.deviceTasks.taskState[
self.task_name]
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.TICKET_CREATE_OK.format(
self.shared[c.TASK_SHARED_TICKET]),
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.TICKET_CREATE_NOK.
format(self.shared[c.TASK_SHARED_TICKET],
resp.status_code))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.TICKET_CREATE_NOK.format(
self.shared[c.TASK_SHARED_TICKET],
resp.status_code))
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.TICKET_CREATE_NOK.format(
self.shared[c.TASK_SHARED_TICKET],
resp.status_code))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.TICKET_CREATE_NOK.format(
self.shared[c.TASK_SHARED_TICKET],
resp.status_code))
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.TICKET_CONN_NOK.format(
url, resp.status_code))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.TICKET_CONN_NOK.format(
url, resp.status_code))
def run_task(self):
"""
Provision device images
:param sample_device: A device object for which the image provisioning should be done
:return:
"""
target_version = getattr(
self.grp_cfg.TASKS.Provision.Software.TargetVersion,
self.sample_device.deviceModel, None)
if self.sample_device.deviceStatus == c.DEVICE_STATUS_REBOOTED:
# Device has been rebooted do not update again
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALLED_VERS.format(
self.sample_device.softwareVersion))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_TARGET_VERS.format(target_version))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_NO_UPDATE_NEEDED_SAME)
self.sample_device.deviceIsRebooted = False
self.update_task_state(new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_START_UPDATE.format(
self.sample_device.deviceSerial))
SoftwareTask.sample_devices = {
self.sample_device.deviceSerial: self.sample_device
}
if target_version is not None:
feedback = Software.compare_device_vers_with_target_vers(
self.sample_device.softwareVersion, target_version)
if feedback == 0:
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=logmsg.SW_DONE_SAME_VERS)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALLED_VERS.format(
self.sample_device.softwareVersion))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_TARGET_VERS.format(target_version))
Tools.emit_log(task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': logmsg.SW_DONE_SAME_VERS
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO,
message=logmsg.SW_NO_UPDATE_NEEDED_SAME)
elif feedback == 1:
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=logmsg.SW_DONE_DEV_NEWER_VERS)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALLED_VERS.format(
self.sample_device.softwareVersion))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_TARGET_VERS.format(target_version))
Tools.emit_log(task_name=self.task_name,
task_state={
'taskState':
self.task_state,
'taskStateMsg':
logmsg.SW_DONE_DEV_NEWER_VERS
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO,
message=logmsg.SW_NO_UPDATE_NEEDED_NEWER)
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_INSTALLED_VERS.format(
self.sample_device.softwareVersion))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_TARGET_VERS.format(target_version))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_UPDATE_NEEDED.format(
self.sample_device.softwareVersion,
target_version))
filename = Software.get_software_image_name(
self.sample_device,
target_version,
grp_cfg=self.grp_cfg)
if filename:
full_path = self.grp_cfg.TASKS.Provision.Software.ImageDir + filename
if self.sample_device.deviceConnection.connected:
self.sample_device = self.install_device_software(
full_path, filename, target_version)
if self.sample_device is not None:
if self.task_state != c.TASK_STATE_FAILED and self.task_state != c.TASK_STATE_REBOOTING:
if self.sample_device.deviceConnection is not None:
self.sample_device.deviceConnection.facts_refresh(
keys='version')
self.sample_device.softwareVersion = self.sample_device.deviceConnection.facts[
"version"]
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.
TASK_STATE_MSG_DONE)
Tools.emit_log(
task_name=self.task_name,
task_state={
'taskState':
self.task_state,
'taskStateMsg':
c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO,
message=logmsg.
SW_NO_UPDATE_NEEDED_SAME)
else:
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_CONN_NOK.format(
self.sample_device.deviceIP))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=c.
TASK_STATE_MSG_FAILED)
return
else:
return
else:
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_CONN_NOK.format(
self.sample_device.deviceIP))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_CONN_NOK.
format(self.sample_device.deviceIP))
else:
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.SW_CONN_NOK.format(
self.sample_device.deviceIP))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_CONN_NOK.format(
self.sample_device.deviceIP))
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_IMG_NOK.format(
target_version))
else:
self.logger.info(
Tools.create_log_msg(
self.task_name, self.sample_device.deviceSerial,
logmsg.SW_NO_TARGET_VERS_FOUND.format(
self.sample_device.deviceModel)))
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.SW_IMG_VALUE_NOK.format(
self.sample_device.deviceGroup))
def emit(self,
task_name=None,
task_state=None,
sample_device=None,
grp_cfg=None,
shared=None,
message=None,
level=c.LOGGER_LEVEL_INFO):
if 'Ticket' in grp_cfg.TASKS.Sequence:
if c.TASK_SHARED_TICKET in shared:
url = 'https://{0}:{1}/login'.format(
grp_cfg.TASKS.Provision.Ticket.Address,
grp_cfg.TASKS.Provision.Ticket.Port)
session = requests.Session()
data = {
'username':
"******".format(grp_cfg.TASKS.Provision.Ticket.User),
'password':
"******".format(grp_cfg.TASKS.Provision.Ticket.Password),
'eauth':
"{0}".format(grp_cfg.TASKS.Provision.Ticket.Eauth),
}
resp = None
try:
resp = session.post(url, json=data, verify=False)
except ConnectionError as cer:
Tools.emit_log(task_name=task_name,
sample_device=sample_device,
message=cer.message)
if resp is not None:
if resp.status_code == 200:
url = 'https://{0}:{1}/'.format(
grp_cfg.TASKS.Provision.Ticket.Address,
grp_cfg.TASKS.Provision.Ticket.Port)
try:
env = Environment(autoescape=False,
loader=FileSystemLoader(
grp_cfg.TASKS.Provision.
Ticket.TemplateDir),
trim_blocks=True,
lstrip_blocks=True)
c.logger.info(
Tools.create_log_msg(
self.__class__.__name__,
sample_device.deviceSerial,
'Found template directory <{0}>)'.format(
grp_cfg.TASKS.Provision.Ticket.
TemplateDir)))
except TemplateNotFound as err:
c.logger.info(
Tools.create_log_msg(
self.__class__.__name__,
sample_device.deviceSerial,
'Error in getting template directory <{0}>'
.format(err.message)))
return
try:
template = env.get_template(
grp_cfg.TASKS.Provision.Ticket.
TicketUpdateTemplate)
ticket_updated = template.render(
deviceSerial=sample_device.deviceSerial,
deviceName=sample_device.deviceName,
deviceModel=sample_device.deviceModel,
deviceGroup=sample_device.deviceGroup,
deviceStatus=sample_device.deviceStatus,
lastSeen=sample_device.deviceTimeStamp,
taskName=task_name,
tasks=task_state)
except TemplateNotFound as err:
c.logger.info(
Tools.create_log_msg(
self.__class__.__name__,
sample_device.deviceSerial,
'Error in getting template file <{0}{1}>'.
format(
grp_cfg.TASKS.Provision.Ticket.
TemplateDir, err.message)))
return
data = {
"client":
"runner",
"fun":
"{0}".format(
grp_cfg.TASKS.Provision.Ticket.Functions[1]),
"ticket_id":
shared[c.TASK_SHARED_TICKET],
"text":
"{0}".format(ticket_updated),
"status":
""
}
resp = session.post(url, json=data, verify=False)
if resp.status_code == 200:
url = 'https://{0}:{1}/logout'.format(
grp_cfg.TASKS.Provision.Ticket.Address,
grp_cfg.TASKS.Provision.Ticket.Port)
resp = session.post(url, verify=False)
if resp.status_code == 200:
c.logger.info(
Tools.create_log_msg(
self.__class__.__name__,
sample_device.deviceSerial,
'Successfully updated ticket with ID <{0}>'
.format(shared[c.TASK_SHARED_TICKET])))
else:
c.logger.info(
Tools.create_log_msg(
self.__class__.__name__,
sample_device.deviceSerial,
'Failure in updating ticket <{0}> with error <{1}>'
.format(shared[c.TASK_SHARED_TICKET],
resp.status_code)))
else:
c.logger.info(
Tools.create_log_msg(
self.__class__.__name__,
sample_device.deviceSerial,
'Failure in updating ticket <{0}>'.format(
shared[c.TASK_SHARED_TICKET])))
else:
c.logger.info(
Tools.create_log_msg(
self.__class__.__name__, sample_device.deviceSerial,
'Not updating ticket since no ticket id yet'))
else:
c.logger.info(
Tools.create_log_msg(
self.__class__.__name__, sample_device.deviceSerial,
'Not processing ticket update since not in task sequence'))
def dep_configuration_cert(self):
self.logger.info(
Tools.create_log_msg(
self.task_name, self.sample_device.deviceSerial,
'Processing configuration task deps for cert task'))
if self.grp_cfg.TASKS.Provision.Cert.PortForwarding:
try:
eurl = self.grp_cfg.TASKS.Provision.Cert.EnrollmentUrl
rurl = self.grp_cfg.TASKS.Provision.Cert.RevocationUrl
eurl = 'http://{0}:{1}/{2}'.format(
self.sample_device.deviceIP,
str(self.grp_cfg.TASKS.Provision.Cert.LocalFwdPort), eurl)
rurl = 'http://{0}:{1}/{2}'.format(
self.sample_device.deviceIP,
str(self.grp_cfg.TASKS.Provision.Cert.LocalFwdPort), rurl)
self.sample_device.deviceConfigData['device']['cert'][
'enrollment_url'] = eurl
self.sample_device.deviceConfigData['device']['cert'][
'revocation_url'] = rurl
except (TemplateNotFound, IOError) as err:
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.
CONF_TASK_CFG_TEMPLATE_ERROR.format(
err.errno, err.strerror,
err.filename))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_CFG_TEMPLATE_ERROR.format(
err.errno, err.strerror, err.filename))
return None
else:
try:
eurl = self.grp_cfg.TASKS.Provision.Cert.EnrollmentUrl
rurl = self.grp_cfg.TASKS.Provision.Cert.RevocationUrl
eurl = 'http://{0}:{1}/{2}'.format(
self.grp_cfg.TASKS.Provision.Cert.RemoteFwdHost,
str(self.grp_cfg.TASKS.Provision.Cert.RemoteFwdHostPort),
eurl)
rurl = 'http://{0}:{1}/{2}'.format(
self.grp_cfg.TASKS.Provision.Cert.RemoteFwdHost,
str(self.grp_cfg.TASKS.Provision.Cert.RemoteFwdHostPort),
rurl)
self.sample_device.deviceConfigData['device']['cert'][
'enrollment_url'] = eurl
self.sample_device.deviceConfigData['device']['cert'][
'revocation_url'] = rurl
except (TemplateNotFound, IOError) as err:
self.update_task_state(new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.
CONF_TASK_CFG_TEMPLATE_ERROR.format(
err.errno, err.strerror,
err.filename))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_CFG_TEMPLATE_ERROR.format(
err.errno, err.strerror, err.filename))
return None
def run_task(self):
"""
Provision device config
:param sample_device: A device object for which the config provisioning should be done
:return:
"""
self.logger.info(
Tools.create_log_msg(
self.task_name, self.sample_device.deviceSerial,
logmsg.CONF_TASK_INIT.format(
format(self.sample_device.deviceSerial))))
configurator = Configuration()
resp = configurator.prepare_device_config(
sample_device=self.sample_device)
self._device_config_file = resp['configfilename']
if self.sample_device.deviceConnection is not None:
self.sample_device.deviceConnection.load_replace_candidate(
filename=self.grp_cfg.TASKS.Provision.Configuration.
ConfigFileHistory + self._device_config_file)
self.update_task_state(new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.CONF_TASK_COMMIT)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_COMMIT)
# Todo: Check Exception
try:
self.sample_device.deviceConnection.commit_config()
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.CONF_TASK_COMMIT_OK.format(
self._device_config_file),
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
except (ReplaceConfigException, MergeConfigException) as err:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CONF_TASK_COMMIT_NOK.format(err))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_COMMIT_NOK.format(err))
return
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.CONF_TASK_CONN_NOK.format(
self.sample_device.deviceIP))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.CONF_TASK_CONN_NOK.format(
self.sample_device.deviceIP))
return
