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']