def POST(self, action=None):
if action == 'add':
input_json = cherrypy.request.json
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_REST_ASSET_ADD,
payload=input_json,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(
(response.payload[0], escape(response.payload[1])))
elif action == 'map':
input_json = cherrypy.request.json
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_ASSET_UPDATE,
payload=input_json,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(
(response.payload[0], escape(response.payload[1])))
else:
return json.dumps((False, escape('Action not defined')))
def GET(self, action=None, serial=None):
if action == 'getBySiteId':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_ASSET_GET_BY_SITE,
payload=serial,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
# return json.dumps((response.payload[0], response.payload[1]))
return response.payload[0], response.payload[1]
elif action == 'getByAssetSerial':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_ASSET_GET_BY_SERIAL,
payload=serial,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
# return json.dumps((response.payload[0], response.payload[1]))
return response.payload[0], response.payload[1]
else:
# return json.dumps((False, escape('Action not defined')))
return False, escape('Action not defined')
def POST(self, action=None, name=None):
if action == 'start':
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_REST_SVC_START,
payload=name,
source=c.AMQP_PROCESSOR_REST)
response = self._svcp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(response.payload)
elif action == 'stop':
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_REST_SVC_STOP,
payload=name,
source=c.AMQP_PROCESSOR_REST)
response = self._svcp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(response.payload)
elif action == 'restart':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_SVC_RESTART,
payload=name,
source=c.AMQP_PROCESSOR_REST)
response = self._svcp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(response.payload)
def POST(self, action=None):
input_json = cherrypy.request.json
if action == 'add':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_VAL_VAL_ADD,
payload={
'username': input_json['username'],
'password': input_json['password']
},
source=c.AMQP_PROCESSOR_REST)
resp = self._backendp.call(message=message)
resp = jsonpickle.decode(resp)
return json.dumps((resp.payload[0], escape(resp.payload[1])))
elif action == 'del':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_VAL_VAL_DEL,
payload={'username': input_json['username']},
source=c.AMQP_PROCESSOR_REST)
resp = self._backendp.call(message=message)
resp = jsonpickle.decode(resp)
return json.dumps((resp.payload[0], escape(resp.payload[1])))
def GET(self, action=None, name=None):
if action == 'all':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_DEVICE_GET_ALL,
payload=name,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
devices = list()
for serial, data in response.payload.iteritems():
sample_device = data['data'].device_to_json()
devices.append(sample_device)
return '[{0}]'.format(', '.join(devices))
elif action == 'cfgall':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_DEVICE_GET_CFG_ALL,
payload=name,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(response.payload)
elif action == 'config':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_DEVICE_GET_CFG_BY_SERIAL,
payload=name,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
if response.payload[0]:
storageName = response.payload[1]['configConfigSource']
storage = self.storageFact.init_plugin(plugin_name=storageName)
status, msg = storage.get_device_config_data(serialnumber=name,
isRaw=True)
return json.dumps((status, msg))
else:
return json.dumps(
(response.payload[0], escape(response.payload[1])))
else:
return json.dumps((False, escape('Action not defined')))
def update_device_task_state(self,
device_serial=None,
is_callback=None,
task_name=None,
task_state=None):
key = {task_name: task_state['taskStateMsg']}
try:
query = self.DeviceTasks.update(**key). \
where(self.DeviceTasks.owner == device_serial)
except KeyError as ke:
self._logger.info(
Tools.create_log_msg(logmsg.SQLBACKEND, None,
'Key <{0}> not found'.format(ke.message)))
return False, 'Key <{0}> not found'.format(ke.message)
try:
rows = query.execute()
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_DEVICE_UPDATE_TASK_STATE,
payload=[device_serial, task_name, task_state],
source=c.AMQP_PROCESSOR_BACKEND)
self.amqpCl.send_message(message=message)
database.close()
return True, rows
except OperationalError as oe:
self._logger.info(
Tools.create_log_msg(logmsg.SQLBACKEND, None, oe.message))
database.close()
return False, oe.message
def update_device_task_state(self, device_serial=None, is_callback=None, task_name=None, task_state=None):
self.sample_devices_lock.acquire()
try:
try:
backend_device = self.sample_devices[device_serial]['data']
backend_device.deviceTasks.is_callback = False
backend_device.deviceTasks.taskState[task_name] = {'taskState': task_state['taskState'],
'taskStateMsg': task_state['taskStateMsg']}
backend_device.deviceTasks.is_callback = True
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_UPDATE_TASK_STATE,
payload=[device_serial, task_name, task_state],
source=c.AMQP_PROCESSOR_BACKEND)
self.amqpCl.send_message(message=message)
return self.sample_devices[device_serial]['data']
finally:
self.sample_devices_lock.release()
except KeyError as err:
self._logger.info(Tools.create_log_msg(self.__class__.__name__, device_serial,
logmsg.INTBACKEND_KEY_NOK.format(err.message)))
def POST(self, action=None, name=None, descr=None):
if action == 'add':
pass
elif action == 'del':
payload = {'imageName': name}
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_REST_IMAGE_DEL,
payload=payload,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
if response.payload[0]:
# Hardcoded image dir since we do not know group at this stage
if os.path.exists(os.getcwd() + '/images/' + name + '.tgz'):
os.remove('images/' + name + '.tgz')
return json.dumps(
(response.payload[0], escape(response.payload[1])))
else:
return json.dumps(response.payload[0],
'File \<{0}\> not found'.format(name))
else:
return json.dumps(
(response.payload[0], escape(response.payload[1])))
else:
return json.dumps((False, escape('Action not defined')))
def _update_backend(self):
if self.task_type == c.TASK_TYPE_PROVISION or c.TASK_TYPE_VERIFICATION:
if 100 % len(self.grp_cfg.TASKS.Sequence) == 0:
self.sample_device.deviceTaskProgress += self.task_progress
else:
if self.task_state == c.TASK_STATE_DONE:
if self.sample_device.deviceStatus == c.DEVICE_STATUS_DONE:
diff = (100 - (self.task_progress +
self.sample_device.deviceTaskProgress))
new = self.task_progress + self.sample_device.deviceTaskProgress
self.sample_device.deviceTaskProgress = new + diff
else:
self.sample_device.deviceTaskProgress += self.task_progress
else:
self.sample_device.deviceTaskProgress += self.task_progress
dev_conn = self.sample_device.deviceConnection
self.sample_device.deviceConnection = hex(
id(self.sample_device.deviceConnection))
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_UPDATE,
payload=self.sample_device,
source=c.AMQP_PROCESSOR_TASK)
self._backendp.call(message=message)
self.sample_device.deviceConnection = dev_conn
def process_req(ch=None, method=None, props=None, response=None):
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_RESPONSE, payload=response,
source=c.AMQP_PROCESSOR_SVC)
encoded = jsonpickle.encode(message)
ch.basic_publish(exchange='', routing_key=props.reply_to,
properties=pika.BasicProperties(correlation_id=props.correlation_id), body=encoded)
ch.basic_ack(delivery_tag=method.delivery_tag)
def notification(self, **params):
cherrypy.response.status = 201
body = cherrypy.request.body.read()
xml_body = etree.fromstring(body)
ns_orig = 'http://juniper.net/zerotouch-bootstrap-server'
for item in xml_body.iter('{' + ns_orig + '}notification-type'):
if item.text == c.PHS_NOTIFICATION_CONF_APPLIED:
self.logger.info(
Tools.create_log_msg(logmsg.PHS_SERVICE, self.sn_nr,
logmsg.PHS_STAGE1_SUCCESS).format(
params['uid']))
elif item.text == c.PHS_NOTIFICATION_CONF_FAILED:
self.logger.info(
Tools.create_log_msg(
logmsg.PHS_SERVICE, self.sn_nr,
logmsg.PHS_STAGE1_FAILED.format(params['uid'])))
elif item.text == c.PHS_NOTIFICATION_BOOTSTRAP_COMPLETED:
self.logger.info(
Tools.create_log_msg(
logmsg.PHS_SERVICE, self.sn_nr,
logmsg.PHS_BOOTSTRAP_SUCCESS.format(params['uid'])))
if c.SERVICEPLUGIN_OSSH in self.service_chain:
self.logger.info(
Tools.create_log_msg(
logmsg.PHS_SERVICE, self.sn_nr,
logmsg.PHS_SEC_SVC.format(c.SERVICEPLUGIN_OSSH,
c.SERVICEPLUGIN_OSSH)))
return
else:
sample_device = self._source_plugin.run_normalizer(
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
device=self.deviceIP)
# NFX JDM facts return empty serial number so we have to add it here
if self.device_type == 'nfx':
sample_device.deviceSerial = self.sn_nr
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_DEVICE_ADD,
payload=sample_device,
source=c.AMQP_PROCESSOR_SVC)
self._source_plugin.send_message(message=message)
elif item.text == c.PHS_NOTIFICATION_BOOTSTRAP_FAILED:
self.logger.info(
Tools.create_log_msg(
logmsg.PHS_SERVICE, self.sn_nr,
logmsg.PHS_BOOSTRAP_FAILED.format(params['uid'])))
def GET(self, action=None, name=None):
if action == 'all':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_TEMPLATE_GET_ALL,
payload=action,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(response.payload)
elif action == 'config':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_TEMPLATE_GET_BY_NAME,
payload=name,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
if response.payload[0]:
groupName = response.payload[1]['templateDevGrp']
storageName = response.payload[1]['templateConfigSource']
storage = self.storageFact.init_plugin(plugin_name=storageName)
status, msg = storage.get_config_template_data(
serialnumber=name,
templateName=name,
groupName=groupName,
isRaw=True)
if status:
return json.dumps((status, msg))
else:
return json.dumps((status, escape(msg)))
else:
return json.dumps(
(response.payload[0], escape(response.payload[1])))
else:
return json.dumps((False, escape('Action not defined')))
def GET(self, action=None, name=None):
if action == 'all':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_VAL_GET_ALL,
payload=action,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return response.payload[0], response.payload[1]
def run(self):
fd = open('./logs/info.log', 'r+')
for line in self.tail(fd):
payload = json.dumps({
'data': line.strip(),
'action': c.UI_ACTION_UPDATE_LOG_VIEWER
})
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_UI_UPDATE_LOG_VIEWER,
payload=payload,
source=c.AMQP_PROCESSOR_SVC)
self.clp.send_message(message=message)
def second_attempt(self, conn, conn_addr, deviceId):
self._logger.info(Tools.create_log_msg(logmsg.OSSH_SERVICE, conn_addr[0], logmsg.OSSH_CONN_ATTEMPT.format(
c.oss_seen_devices[conn_addr[0]]['attempt'], conn_addr)))
sample_device = self._normalizer.run_normalizer(
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), device=conn_addr[0])
sample_device.deviceConnection = conn.fileno()
sample_device.deviceOsshId = deviceId
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_ADD,
payload=sample_device,
source=c.AMQP_PROCESSOR_SVC)
self._normalizer.send_message(message=message)
def GET(self, action=None, name=None):
if action == 'all':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_IMAGE_GET_ALL,
payload=action,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(response.payload)
else:
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_IMAGE_GET_BY_NAME,
payload=name,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps(response.payload)
def GET(self, siteId=None):
if siteId == 'all':
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_SITE_GET_ALL,
payload=siteId,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps((response.payload[0], response.payload[1]))
else:
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_REST_SITE_GET_BY_ID,
payload=siteId,
source=c.AMQP_PROCESSOR_REST)
response = self._backendp.call(message=message)
response = jsonpickle.decode(response)
return json.dumps((response.payload[0], response.payload[1]))
def action(self, instance, task_name):
from lib.processor import BackendClientProcessor
backendp = BackendClientProcessor(exchange='', routing_key=c.AMQP_RPC_BACKEND_QUEUE)
if isinstance(instance, TaskState):
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_UPDATE_TASK_STATE,
payload={'deviceSerial': getattr(instance, 'deviceSerial', None),
'isCallback': getattr(instance, 'is_callback', None), 'taskName': task_name,
'taskState': instance.taskState[task_name]},
source=task_name)
backendp.call(message=message)
else:
self._logger.info('Unknown task type %s. Can\'t update backend', instance)
def on_modified(self, event):
super(FileHandler, self).on_modified(event)
self.logger.info(
Tools.create_log_msg(
logmsg.FILESVC, None,
logmsg.FILESVC_MODIFIED.format(event.src_path)))
payload = self._source_plugin.run_normalizer(
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
if payload:
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_DEVICE_ADD,
payload=self._source_plugin.run_normalizer(
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
source=c.AMQP_PROCESSOR_SVC)
self._source_plugin.send_message(message=message)
def POST(self):
input_json = cherrypy.request.json
_data = [_file for commit in input_json['commits'] for _file in commit['modified']]
for item in _data:
data = item.rsplit('.', 1)[0]
self.logger.info(Tools.create_log_msg(logmsg.WEBHOOK_SERVICE, data, logmsg.WEBHOOK_RECEIVED.format(data)))
sample_device = self._normalizer.run_normalizer(
timestamp=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), device=data)
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_ADD,
payload=sample_device,
source=c.AMQP_PROCESSOR_SVC)
self._normalizer.send_message(message=message)
def update_device(self, sample_device=None):
query = Device.update(
deviceName=sample_device.deviceName,
deviceModel=sample_device.deviceModel,
deviceSerial=sample_device.deviceSerial,
softwareVersion=sample_device.softwareVersion,
deviceIP=sample_device.deviceIP,
deviceStatus=sample_device.deviceStatus,
deviceTaskProgress=sample_device.deviceTaskProgress,
deviceConfiguration=sample_device.deviceConfiguration,
deviceIsRebooted=sample_device.deviceIsRebooted,
deviceConnection=sample_device.deviceConnection,
deviceGroup=sample_device.deviceGroup,
deviceServicePlugin=sample_device.deviceServicePlugin,
deviceTaskSeq=sample_device.deviceTaskSeq).where(
Device.deviceSerial == sample_device.deviceSerial)
query.execute()
device = Device.get(Device.deviceSerial == sample_device.deviceSerial)
sample_device.deviceName = device.deviceName
sample_device.deviceIP = device.deviceIP
sample_device.deviceSerial = device.deviceSerial
sample_device.deviceModel = device.deviceModel
sample_device.deviceStatus = device.deviceStatus
sample_device.softwareVersion = device.softwareVersion
sample_device.deviceTaskProgress = device.deviceTaskProgress
sample_device.deviceConfiguration = device.deviceConfiguration
sample_device.deviceConnection = device.deviceConnection
sample_device.deviceGroup = device.deviceGroup
sample_device.deviceServicePlugin = device.deviceServicePlugin
sample_device.deviceTaskSeq = device.deviceTaskSeq
database.close()
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_UPDATE,
payload=sample_device,
source=c.AMQP_PROCESSOR_BACKEND)
self.amqpCl.send_message(message=message)
return sample_device
def update_device(self, sample_device=None):
self.sample_devices_lock.acquire()
try:
self.sample_devices[sample_device.deviceSerial]['data'] = sample_device
finally:
self.sample_devices_lock.release()
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_UPDATE,
payload=self.sample_devices[sample_device.deviceSerial]['data'],
source=c.AMQP_PROCESSOR_BACKEND)
self.amqpCl.send_message(message=message)
return self.sample_devices[sample_device.deviceSerial]['data']
def close_dev_conn(self, sample_device):
self._logger.info(Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_CLOSE_DEV_CONN.format(
hex(id(sample_device.deviceConnection)))))
if isinstance(sample_device.deviceConnection, NetworkDriver):
try:
sample_device.deviceConnection.close()
except TimeoutExpiredError as texe:
self._logger.info(
Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_CONN_ERR_CLOSE.format(
sample_device.deviceIP, texe.message)))
return
elif isinstance(sample_device.deviceConnection, jnpr.junos.device.Device):
if sample_device.deviceServicePlugin == c.SERVICEPLUGIN_OSSH:
sample_device.deviceConnection = ''
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_SVC_OSSH_CLOSE_SOCKET,
payload=sample_device,
source=c.AMQP_PROCESSOR_TASK)
response = self._svcp.call(message=message)
response = jsonpickle.decode(response)
elif sample_device.deviceConnection.connected:
try:
sample_device.deviceConnection.close()
except TimeoutExpiredError as texe:
self._logger.info(
Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_CONN_ERR_CLOSE.format(
sample_device.deviceIP, texe.message)))
return
def run_normalizer(self, timestamp=None, device=None):
if device:
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_DEVICE_GET_BY_SN,
payload=device,
source=c.AMQP_PROCESSOR_SVC)
backendp = BackendClientProcessor(
exchange='', routing_key=c.AMQP_RPC_BACKEND_QUEUE)
resp = jsonpickle.decode(backendp.call(message=message))
if resp.payload[0]:
sample_device = resp.payload[1]
sample_device.deviceSerial = device
sample_device.deviceServicePlugin = c.SERVICEPLUGIN_WEBHOOK
sample_device.deviceTimeStamp = timestamp
return sample_device
else:
return False
else:
return False
def validate_phc(self, realm, username, password):
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_SVC_PHS_VALIDATE,
payload={
'username': username,
'password': password
},
source=c.AMQP_PROCESSOR_TASK)
resp = self._backendp.call(message=message)
resp = jsonpickle.decode(resp)
if resp.payload[0]:
self.logger.info(
Tools.create_log_msg(
logmsg.PHS_SERVICE, username,
logmsg.PHS_VALIDATION_SUCCESS.format(username)))
return True
else:
self.logger.info(
Tools.create_log_msg(
logmsg.PHS_SERVICE, username,
logmsg.PHS_VALIDATION_FAILED.format(username)))
return False
def receive_message(self, ch, method, properties, body):
if body is not None:
ch.basic_ack(delivery_tag=method.delivery_tag)
body_decoded = jsonpickle.decode(body)
Tools.amqp_receive_to_logger(routing_key=method.routing_key, body_decoded=body_decoded)
if isinstance(body_decoded,
AMQPMessage) and c.AMQP_MSG_TYPE_DEVICE_ADD == body_decoded.message_type:
sample_device = body_decoded.payload
status, sample_device = Tools.create_dev_conn(sample_device=sample_device)
if status:
sample_device = Tools.get_device_facts(sample_device=sample_device)
status, data = Tools.get_config(lookup_type=c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG,
sample_device=sample_device)
if status:
sample_device.deviceConfigData = data
try:
sample_device.deviceGroup = data['yapt']['device_group']
except KeyError as ke:
self._logger.info(Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_STOP_NO_DEVGRP.format(ke.message)))
return
status, grp_cfg = Tools.get_config(lookup_type=c.CONFIG_LOOKUP_TYPE_GET_GROUP,
sample_device=sample_device)
if status:
sample_device.deviceGroupData = grp_cfg
grp_cfg = Tools.create_config_view(config_type=c.CONFIG_TYPE_GROUP, stream=grp_cfg)
sample_device.deviceTemplate = grp_cfg.TASKS.Provision.Configuration.DeviceConfTemplateFile
sample_device.deviceTaskSeq = list(grp_cfg.TASKS.Sequence)
dev_conn = sample_device.deviceConnection
sample_device.deviceConnection = hex(id(sample_device.deviceConnection))
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_ADD, payload=sample_device,
source=c.AMQP_PROCESSOR_TASK)
resp = self._backendp.call(message=message)
resp = jsonpickle.decode(resp)
sample_device = resp.payload[1]
sample_device.deviceConnection = dev_conn
self._logger.info(Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_LOAD_TASK_SEQ.format(
sample_device.deviceTaskSeq)))
c.taskq.add_device_task_q(sample_device=sample_device, grp_cfg=grp_cfg)
taskq = c.taskq.get_device_task_q(sn=sample_device.deviceSerial)
self._logger.debug(Tools.create_log_msg(self.name, sample_device.deviceSerial,
'Device status: <{0}>'.format(
sample_device.deviceStatus)))
if taskq:
for task in taskq:
self._logger.debug(Tools.create_log_msg(self.name, sample_device.deviceSerial,
'Task: <{0}> status: <{1}>'.format(
task.task_name, task.task_state)))
if task.task_state == c.TASK_STATE_INIT:
task.pre_run_task()
task.run_task()
task.post_run_task()
if task.task_state == c.TASK_STATE_REBOOTING:
self._logger.debug(
Tools.create_log_msg(self.name, sample_device.deviceSerial,
'Task: <{0}> status: <{1}>'.format(
task.task_name, task.task_state)))
self._logger.info(
Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_STOP_DEV_REBOOT.format(
sample_device.deviceSerial)))
break
elif task.task_state == c.TASK_STATE_FAILED:
self._logger.debug(
Tools.create_log_msg(self.name, sample_device.deviceSerial,
'Task: <{0}> status: <{1}>'.format(
task.task_name, task.task_state)))
self._logger.info(
Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_TASK_ERROR.format(
task.task_name, )))
self.close_dev_conn(sample_device=sample_device)
break
elif task.task_state == c.TASK_STATE_REBOOTING:
task.pre_run_task()
task.run_task()
task.post_run_task()
if task.task_state == c.TASK_STATE_FAILED:
self._logger.debug(
Tools.create_log_msg(self.name, sample_device.deviceSerial,
'Task: <{0}> status: <{1}>'.format(
task.task_name, task.task_state)))
self._logger.info(
Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_TASK_ERROR.format(
task.task_name, )))
self.close_dev_conn(sample_device=sample_device)
break
elif task.task_state == c.TASK_STATE_DONE:
pass
elif task.task_state == c.TASK_STATE_FAILED:
self._logger.debug(
Tools.create_log_msg(self.name, sample_device.deviceSerial,
'Task: <{0}> status: <{1}>'.format(
task.task_name, task.task_state)))
self._logger.info(
Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_TASK_ERROR.format(
task.task_name, )))
self.close_dev_conn(sample_device=sample_device)
break
else:
self._logger.info(Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
'Task <{0}> state: <{1}> unknown'.format(
task.task_name, task.task_state)))
break
# print 'After running all tasks device status is: <{0}>'.format(
# sample_device.deviceStatus)
if sample_device.deviceStatus == c.DEVICE_STATUS_DONE:
c.taskq.del_device_task_q(sample_device.deviceSerial)
else:
self._logger.info(Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_STOP_NO_DEVGRP_CFG.format(grp_cfg)))
self.close_dev_conn(sample_device=sample_device)
return
else:
self._logger.info(Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_STOP_NO_DEV_CFG.format(data)))
self.close_dev_conn(sample_device=sample_device)
return
else:
self._logger.info(Tools.create_log_msg(logmsg.TASKP, sample_device.deviceSerial,
logmsg.TASKP_CONN_ERR.format(sample_device.deviceSerial)))
return
else:
Tools.amqp_receive_error_to_logger(routing_key=method.routing_key, body_decoded=body_decoded)
else:
self._logger.info(Tools.create_log_msg(logmsg.TASKP, None, logmsg.TASKP_DEFECT_MSG))
def get_config(self, lookup_type=None, **kvargs):
"""
obtain specific config type <lookup_type> from configured source in <DeviceConfSrcPlugins>
:param lookup_type: defines which data we looking for e.g. device_data / group_data / template
:return:
"""
osshid = None
isRaw = None
templateName = None
groupName = None
from lib.pluginfactory import StoragePlgFact
storageFact = StoragePlgFact()
storage_plgs = storageFact.init_plugins()
c.logger.debug(Tools.create_log_msg('TOOLS', 'get_config', kvargs))
if 'sample_device' in kvargs:
sample_device = kvargs.get('sample_device')
sn = sample_device.deviceSerial
osshid = sample_device.deviceOsshId
groupName = sample_device.deviceGroup
templateName = sample_device.deviceTemplate
elif 'serialnumber' in kvargs and 'deviceOsshId' in kvargs:
sn = kvargs.get('serialnumber')
osshid = kvargs.get('deviceOsshId')
elif 'templateName' in kvargs and 'groupName' in kvargs and 'isRaw' in kvargs:
templateName = kvargs.get('templateName')
groupName = kvargs.get('groupName')
isRaw = kvargs.get('isRaw')
sn = templateName
elif 'groupName' in kvargs and 'isRaw' in kvargs:
groupName = kvargs.get('groupName')
isRaw = kvargs.get('isRaw')
sn = groupName
elif 'configSerial' in kvargs and 'isRaw' in kvargs:
sn = kvargs.get('configSerial')
isRaw = kvargs.get('isRaw')
else:
return False, 'Parameters not matching'
c.logger.debug(Tools.create_log_msg(logmsg.STORAGE_PLG, sn if sn else osshid,
logmsg.STORAGE_PLG_LOAD.format(c.conf.STORAGE.DeviceConfSrcPlugins)))
if c.conf.STORAGE.DeviceConfSrcPlugins:
for key, storage in storage_plgs.iteritems():
if lookup_type == c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG:
# check ooba
if c.conf.STORAGE.DeviceConfOoba:
c.logger.info(Tools.create_log_msg(logmsg.STORAGE_PLG, sn if sn else osshid,
'Checking config id mapping in asset database'))
from lib.amqp.amqpmessage import AMQPMessage
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_REST_ASSET_GET_BY_SERIAL,
payload=osshid if osshid else sn,
source=c.AMQP_PROCESSOR_REST)
from lib.processor import BackendClientProcessor
_backendp = BackendClientProcessor(exchange='', routing_key=c.AMQP_RPC_BACKEND_QUEUE)
response = _backendp.call(message=message)
response = jsonpickle.decode(response)
# Check if mapping found
if response.payload[0]:
c.logger.info(Tools.create_log_msg(logmsg.STORAGE_PLG, sn if sn else osshid,
'Successfully retrieved config id mapping for {0}<-->{1}'.format(
osshid if osshid else sn, response.payload[1])))
sn = response.payload[1]
else:
c.logger.info(Tools.create_log_msg(logmsg.STORAGE_PLG, sn if sn else osshid,
'Failed to retrieve config id mapping for {0}<-->{1}'.format(
sn, response.payload)))
return response.payload[0], response.payload[1]
status, data = storage.get_device_config_data(serialnumber=sn, isRaw=isRaw)
if status:
return status, data
else:
continue
elif lookup_type == c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG_FILE:
status, filename = storage.get_device_config_data_file(serialnumber=sn, deviceOsshId=osshid)
c.logger.debug(Tools.create_log_msg(logmsg.STORAGE_PLG, sn if sn else osshid,
logmsg.STORAGE_PLG_EXEC.format(storage)))
if status:
return status, filename
else:
continue
elif lookup_type == c.CONFIG_LOOKUP_TYPE_GET_TEMPLATE:
if sn and templateName and groupName:
isFile, template = storage.get_config_template_data(serialnumber=sn,
templateName=templateName,
groupName=groupName, isRaw=isRaw)
c.logger.debug(Tools.create_log_msg(logmsg.STORAGE_PLG, sn if sn else osshid,
logmsg.STORAGE_PLG_EXEC.format(storage)))
if isFile:
return isFile, template
else:
c.logger.info(Tools.create_log_msg(logmsg.STORAGE_PLG, sn if sn else osshid,
logmsg.STORAGE_TEMPLATE_NOK(templateName, templateName)))
continue
elif lookup_type == c.CONFIG_LOOKUP_TYPE_GET_TEMPLATE_FILE:
if sn and templateName:
isFile, template = storage.get_config_template_file(serialnumber=sn,
templateName=templateName,
groupName=groupName)
c.logger.debug(logmsg.STORAGE_PLG, sn if sn else osshid,
logmsg.STORAGE_PLG_EXEC.format(storage))
if isFile:
return isFile, template
else:
continue
elif lookup_type == c.CONFIG_LOOKUP_TYPE_TEMPLATE_BOOTSTRAP:
if osshid:
isFile, template = storage.get_bootstrap_config_template(serialnumber=osshid,
path=kvargs.get('path'),
file=kvargs.get('file'))
c.logger.debug(logmsg.STORAGE_PLG, sn if sn else osshid,
logmsg.STORAGE_PLG_EXEC.format(storage))
if isFile:
return template
else:
continue
elif lookup_type == c.CONFIG_LOOKUP_TYPE_GET_GROUP:
if sn and groupName:
status, groupvars = storage.get_group_data(serialnumber=sn, groupName=groupName, isRaw=isRaw)
c.logger.debug(Tools.create_log_msg(logmsg.STORAGE_PLG, sn if sn else osshid,
logmsg.STORAGE_PLG_EXEC.format(storage)))
if status:
return True, groupvars
else:
continue
elif lookup_type == c.CONFIG_LOOKUP_TYPE_GET_GROUP_FILE:
if sn and groupName:
isFile, filename = storage.get_group_data_file(serialnumber=sn, group=groupName)
c.logger.debug(logmsg.STORAGE_PLG, sn if sn else osshid,
logmsg.STORAGE_PLG_EXEC.format(storage))
if isFile:
return filename
else:
continue
return False, 'No device or group or template data found'
else:
c.logger.info(logmsg.STORAGE_PLG, sn if sn else osshid, 'Config Source plugin sequence empty')
return
def send_message_to_amqp(self, data=None):
message = AMQPMessage(message_type=data,
payload=data,
source='CPAMQPPlugin')
self.amqpCl.send_message(message=message)
def add_device(self, new_device=None):
device, created = Device.get_or_create(
deviceSerial=new_device.deviceSerial,
defaults={
'deviceName': new_device.deviceName,
'deviceModel': new_device.deviceModel,
'deviceSerial': new_device.deviceSerial,
'softwareVersion': new_device.softwareVersion,
'deviceIP': new_device.deviceIP,
'deviceStatus': c.DEVICE_STATUS_NEW,
'deviceTimeStamp': new_device.deviceTimeStamp,
'deviceConfiguration': new_device.deviceConfiguration,
'deviceConnection': new_device.deviceConnection,
'deviceGroup': new_device.deviceGroup,
'deviceServicePlugin': new_device.deviceServicePlugin,
'deviceTaskSeq': new_device.deviceTaskSeq
})
if created:
dpts = self.DeviceTasks.create(owner=new_device.deviceSerial)
dpts.save()
database.close()
new_device.deviceTasks.is_callback = False
for item in new_device.deviceTaskSeq:
new_device.deviceTasks.taskState[item] = {
'taskState': c.TASK_STATE_INIT,
'taskStateMsg': c.TASK_STATE_MSG_INIT
}
key = {item: c.TASK_STATE_MSG_WAIT}
query = self.DeviceTasks.update(**key). \
where(self.DeviceTasks.owner == new_device.deviceSerial)
query.execute()
new_device.deviceTasks.is_callback = True
new_device.deviceStatus = c.DEVICE_STATUS_NEW
# Set deviceSerial as reference in task observer
new_device.deviceTasks.deviceSerial = new_device.deviceSerial
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_ADD,
payload=new_device,
source=c.AMQP_PROCESSOR_BACKEND)
self.amqpCl.send_message(message=message)
return True, new_device
else:
if device.deviceIsRebooted:
new_device.deviceStatus = c.DEVICE_STATUS_REBOOTED
new_device.deviceTaskProgress = device.deviceTaskProgress
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_UI_UPDATE_AND_REBOOT,
payload=new_device,
source=c.AMQP_PROCESSOR_BACKEND)
else:
new_device.deviceStatus = c.DEVICE_STATUS_EXISTS
new_device.deviceTaskProgress = 0.0
message = AMQPMessage(
message_type=c.AMQP_MSG_TYPE_UI_UPDATE_AND_RESET,
payload=new_device,
source=c.AMQP_PROCESSOR_BACKEND)
device.deviceName = new_device.deviceName
device.deviceIP = new_device.deviceIP
device.deviceStatus = new_device.deviceStatus
device.softwareVersion = new_device.softwareVersion
device.deviceTimeStamp = new_device.deviceTimeStamp
device.deviceConfiguration = new_device.deviceConfiguration
device.deviceConnection = new_device.deviceConnection
device.deviceGroup = new_device.deviceGroup
device.deviceServicePlugin = new_device.deviceServicePlugin
device.deviceTaskSeq = new_device.deviceTaskSeq
new_device.deviceIsRebooted = device.deviceIsRebooted
device.save()
task = self.DeviceTasks.get(
device.deviceSerial == self.DeviceTasks.owner)
# Set deviceSerial as reference in task observer
new_device.deviceTasks.deviceSerial = new_device.deviceSerial
new_device.deviceTasks.is_callback = False
for item in device.deviceTaskSeq:
new_device.deviceTasks.taskState[item] = task._data[item]
new_device.deviceTasks.is_callback = True
database.close()
self.amqpCl.send_message(message=message)
return True, new_device
def add_device(self, new_device=None):
if len(self.sample_devices) == 0:
new_device.deviceStatus = c.DEVICE_STATUS_NEW
self.sample_devices_lock.acquire()
try:
self.sample_devices[new_device.deviceSerial] = dict()
self.sample_devices[new_device.deviceSerial]['data'] = new_device
if c.DEVICE_STATUS_NEW == self.sample_devices[new_device.deviceSerial]['data'].deviceStatus:
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.is_callback = False
for task in self.sample_devices[new_device.deviceSerial]['data'].deviceTaskSeq:
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.taskState[task] = {
'taskState': c.TASK_STATE_WAIT,
'taskStateMsg': c.TASK_STATE_MSG_WAIT}
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.is_callback = True
finally:
self.sample_devices_lock.release()
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_ADD,
payload=self.sample_devices[new_device.deviceSerial]['data'],
source=c.AMQP_PROCESSOR_BACKEND)
self.amqpCl.send_message(message=message)
return self.sample_devices[new_device.deviceSerial]['data']
elif len(self.sample_devices) > 0:
if new_device.deviceSerial in self.sample_devices:
self.sample_devices_lock.acquire()
try:
backend_device = self.sample_devices[new_device.deviceSerial]['data']
if new_device.deviceTimeStamp > backend_device.deviceTimeStamp:
backend_device = new_device
backend_device.deviceStatus = c.DEVICE_STATUS_EXISTS
self.sample_devices[new_device.deviceSerial]['data'] = backend_device
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.is_callback = False
for task in self.sample_devices[new_device.deviceSerial]['data'].deviceTaskSeq:
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.taskState[task] = {
'taskState': c.TASK_STATE_WAIT,
'taskStateMsg': c.TASK_STATE_MSG_WAIT}
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.is_callback = True
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_UI_UPDATE_AND_RESET,
payload=backend_device, source=c.AMQP_PROCESSOR_BACKEND)
self.amqpCl.send_message(message=message)
return self.sample_devices[backend_device.deviceSerial]['data']
else:
self._logger.info(Tools.create_log_msg(logmsg.INTBACKEND, new_device.deviceSerial,
logmsg.INTBAKCEND_TIMESTAMP_NOK))
finally:
self.sample_devices_lock.release()
else:
new_device.deviceStatus = c.DEVICE_STATUS_NEW
self.sample_devices_lock.acquire()
try:
self.sample_devices[new_device.deviceSerial] = dict()
self.sample_devices[new_device.deviceSerial]['data'] = new_device
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.is_callback = False
for task in self.sample_devices[new_device.deviceSerial]['data'].deviceTaskSeq:
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.taskState[task] = {
'taskState': c.TASK_STATE_WAIT,
'taskStateMsg': c.TASK_STATE_MSG_WAIT}
self.sample_devices[new_device.deviceSerial]['data'].deviceTasks.is_callback = True
finally:
self.sample_devices_lock.release()
message = AMQPMessage(message_type=c.AMQP_MSG_TYPE_DEVICE_ADD,
payload=self.sample_devices[new_device.deviceSerial]['data'],
source=c.AMQP_PROCESSOR_BACKEND)
self.amqpCl.send_message(message=message)
return self.sample_devices[new_device.deviceSerial]['data']
