def get_device_config_data(self, serialnumber=None, isRaw=None): status, data = self.authenticate_oauth() if status: try: project = self.gl.projects.get(c.conf.STORAGE.Cgitlab.DevCfg) file_path = '{0}{1}'.format(serialnumber, c.CONFIG_FILE_SUFFIX_DEVICE) except (GitlabConnectionError, GitlabError) as gle: return False, 'Failed to get project with error: <0>'.format(gle.message) try: f = project.files.get(file_path=file_path, ref='master') except GitlabError as ge: return False, 'Failed to get device config with error: <{0}>'.format(ge.message) if isRaw: return True, f.decode() else: try: datavars = yaml.safe_load(f.decode()) self.logger.info(Tools.create_log_msg(self.name, serialnumber, logmsg.GIT_DEV_CFG_OK.format( serialnumber + c.CONFIG_FILE_SUFFIX_DEVICE))) return True, datavars except yaml.YAMLError as exc: self.logger.info( '{0}-[{1}]: Error in loading config file <{2}> --> {3}'.format(self.name, serialnumber, serialnumber + c.CONFIG_FILE_SUFFIX_DEVICE, exc)) return False, self.logger.info( '{0}-[{1}]: Error in loading config file <{2}> --> {3}'.format(self.name, serialnumber, serialnumber + c.CONFIG_FILE_SUFFIX_DEVICE, exc)) else: return status, data
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 get_device(self, serial_number=None): try: device = Device.get(Device.deviceSerial == serial_number) sample_device = SampleDevice( deviceIP=device.deviceIP, deviceStatus=device.deviceStatus, deviceServicePlugin=device.deviceServicePlugin, deviceTimeStamp=device.deviceTimeStamp) sample_device.deviceSerial = serial_number return True, sample_device except DoesNotExist as dne: self._logger.info( Tools.create_log_msg(logmsg.SQLBACKEND, None, dne.message)) return False, dne.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 stop_service(self): if self.status == c.SVC_STARTED: self.ossh_svc_t.stop() # self._sock.shutdown(socket.SHUT_RDWR) self.ossh_svc_t.join() self.status = c.SVC_STOPPED self.logger.info( Tools.create_log_msg(logmsg.OSSH_SERVICE, None, logmsg.OSSH_STOPPED.format(c.conf.SERVICES.Ossh.ServiceBindAddress, c.conf.SERVICES.Ossh.ServiceListenPort))) return self.status else: return self.status
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 received_message(self, m): try: _data = json.loads(m.data) except ValueError as ve: c.logger.info( Tools.create_log_msg(logmsg.WSHDLR, self.clientname, logmsg.WSHDLR_RCVD_DATA_NOK.format(ve))) return None all_clients = cherrypy.engine.publish('get-clients') for _clients in all_clients: for _client_name, client_ws in _clients.iteritems(): if not client_ws.terminated: client_ws.send(m.data)
def init_port_fwd(self): if self.sample_device.deviceConnection.connected: self.reverse_forward_tunnel( int(self.grp_cfg.TASKS.Provision.Cert.LocalFwdPort), self.grp_cfg.TASKS.Provision.Cert.RemoteFwdHost, int(self.grp_cfg.TASKS.Provision.Cert.RemoteFwdHostPort), self.sample_device.deviceConnection._conn._session.transport, self.event, self.cancel_chan) else: self.logger.info( Tools.create_log_msg(logmsg.SSHFWD, self.sample_device.deviceSerial, logmsg.SSHFWD_CONN_NOK)) return False
def stop_service(self): if self.status == c.SVC_STARTED: self.p.terminate() self.p.join() self.status = c.SVC_STOPPED self.logger.info( Tools.create_log_msg( logmsg.PHS_SERVICE, None, logmsg.PHS_STOPPED.format( c.conf.SERVICES.Phs.ServiceBindAddress, c.conf.SERVICES.Phs.ServiceListenPort))) return self.status else: return self.status
def authenticate_oauth(self): URL = '{0}://{1}:{2}'.format(c.conf.STORAGE.Cgitlab.Protocol, c.conf.STORAGE.Cgitlab.Address, c.conf.STORAGE.Cgitlab.Port) LOGIN_URL = '{0}{1}'.format(URL, c.conf.STORAGE.Cgitlab.LoginUrl) payload = { "grant_type": "password", "username": c.conf.STORAGE.Cgitlab.User, "password": c.conf.STORAGE.Cgitlab.Password } headers = { 'content-type': "application/json", 'cache-control': "no-cache" } try: self.logger.debug(Tools.create_log_msg(self.name, None, "POST {0}, {1}, {2}".format(LOGIN_URL, payload, headers))) response = requests.request("POST", LOGIN_URL, data=json.dumps(payload), headers=headers) except ConnectionError as ce: self.logger.info(Tools.create_log_msg(self.name, None, 'Connection error: <{0}>'.format(ce.message))) return False, 'Connection error: <{0}>'.format(ce.message) if response.status_code == 200: resp = json.loads(response.content) self.logger.debug(Tools.create_log_msg(self.name, None, resp)) if 'access_token' in resp: access_token = resp['access_token'] self.gl = gitlab.Gitlab(URL, oauth_token=access_token) return True, logmsg.GIT_AUTH_OK else: self.logger.info(Tools.create_log_msg(self.name, None, logmsg.GIT_AUTH_ACCESS_TOKEN_NOK)) return False, logmsg.GIT_AUTH_NOK else: self.logger.debu(Tools.create_log_msg(self.name, None, response.status_code)) self.logger.debug(Tools.create_log_msg(self.name, None, response.headers)) self.logger.debug(Tools.create_log_msg(self.name, None, response)) self.logger.info(Tools.create_log_msg(self.name, None, logmsg.GIT_AUTH_NOK)) return False, logmsg.GIT_AUTH_NOK
def prepare_vnf_boostrap_config(self, serialnumber=None, grp_cfg=None, vnf_type=None): now = datetime.datetime.now().strftime('%Y-%m-%d-%H%M') status, data = Tools.get_config( lookup_type=c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG, serialnumber=None, deviceOsshId=serialnumber) if status: if vnf_type == c.VNF_TYPE_JUNIPER: data['device']['ossh_secret'] = data['device']['ossh_secret'] data['device'][ 'ossh_ip'] = c.conf.SERVICES.Ossh.ServiceBindAddress data['device'][ 'ossh_port'] = c.conf.SERVICES.Ossh.ServiceListenPort heading = "## Last changed: " + now + "\n" data['heading'] = heading status, template = Tools.get_config( lookup_type=c.CONFIG_LOOKUP_TYPE_GET_TEMPLATE, serialnumber=None, deviceOsshId=serialnumber, path=data['yapt']['bootstrap_template_dir'], file=data['yapt']['bootstrap_template_file']) if status: config = template.render(data, deviceId=serialnumber) _device_config_file = '{0}-bootstrap-{1}.conf'.format( serialnumber, now) target = open( grp_cfg.TASKS.Provision.Configuration.ConfigFileHistory + _device_config_file, 'w') target.write(config) target.close() return _device_config_file else: self.logger.info( Tools.create_log_msg(logmsg.CONF_DEV_CFG, serialnumber, logmsg.CONF_DEV_CFG_DEV_DATA_ERROR)) return None
def __init__(self, sample_device=None, grp_cfg=None, event=None, cancel_chan=None): self.logger = c.logger self.sample_device = sample_device self.grp_cfg = grp_cfg self.event = event self.cancel_chan = cancel_chan self.logger.info( Tools.create_log_msg( logmsg.SSHFWD, sample_device.deviceSerial, logmsg.SSHFWD_INIT.format( self.sample_device.deviceIP, grp_cfg.TASKS.Provision.Cert.LocalFwdPort, grp_cfg.TASKS.Provision.Cert.RemoteFwdHost, grp_cfg.TASKS.Provision.Cert.RemoteFwdHostPort)))
def __init__(self, group=None, target=None, name=None, args=(), kwargs=None): super(Backend, self).__init__(group=group, target=target, name=name, args=args, kwargs=kwargs) self._logger.debug( Tools.create_log_msg( self.__class__.__name__, None, LogCommon.IS_SUBCLASS.format( self.__class__.__name__, issubclass(Backend, AMQPRpcServerAdapter)))) self.amqpCl = ClientProcessor(exchange=c.conf.AMQP.Exchange, routing_key=c.AMQP_PROCESSOR_UI, queue=c.AMQP_PROCESSOR_UI)
def __init__(self, normalizer, svc_cfg): self.logger = c.logger cherrypy.config.update('{0}/{1}'.format(os.getcwd(), c.SVC_WEBHOOK_CONF)) for module in c.conf.SERVICES.Webhook.Modules: handler = getattr(sys.modules[__name__], module + 'WebHookHandler') cherrypy.tree.mount(handler(normalizer=normalizer, svc_cfg=svc_cfg), script_name='/' + module.lower(), config='{0}/{1}'.format(os.getcwd(), '{0}{1}{2}'.format(c.SVC_WEBHOOK_PATH, module.lower(), '.conf'))) self._webhook_server = Server() self._webhook_server.socket_host = c.conf.SERVICES.Webhook.ServiceBindAddress self._webhook_server.socket_port = c.conf.SERVICES.Webhook.ServiceListenPort self._webhook_server.subscribe() self.logger.info(Tools.create_log_msg(logmsg.WEBHOOK_SERVICE, None, logmsg.WEBHOOK_LISTEN.format(self._webhook_server.socket_host, self._webhook_server.socket_port))) cherrypy.engine.start() cherrypy.engine.block()
def on_request(self, ch, method, props, body): if body is not None: 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_SVC_OSSH_CLOSE_SOCKET == body_decoded.message_type: sample_device = body_decoded.payload if sample_device.deviceIP in c.oss_seen_devices: # Todo: Move to service OSSH sock = c.oss_seen_devices[sample_device.deviceIP]['socket'] sock.shutdown(socket.SHUT_RDWR) sock.close() with c.oss_seen_devices_lck: if sample_device.deviceIP in c.oss_seen_devices: c.oss_seen_devices.pop(sample_device.deviceIP, None) self.process_req(ch=ch, method=method, props=props, response=c.AMQP_MSG_TYPE_RESPONSE) elif isinstance(body_decoded, AMQPMessage) and c.AMQP_MSG_TYPE_REST_SVC_START == body_decoded.message_type: resp = self.registry[body_decoded.payload].start_service() self.process_req(ch=ch, method=method, props=props, response=resp) elif isinstance(body_decoded, AMQPMessage) and c.AMQP_MSG_TYPE_REST_SVC_STOP == body_decoded.message_type: resp = self.registry[body_decoded.payload].stop_service() self.process_req(ch=ch, method=method, props=props, response=resp) elif isinstance(body_decoded, AMQPMessage) and c.AMQP_MSG_TYPE_REST_SVC_RESTART == body_decoded.message_type: resp = self.registry[body_decoded.payload].restart_service() self.process_req(ch=ch, method=method, props=props, response=resp) else: self._logger.info(Tools.create_log_msg('SVCPROCESSOR', None, 'Unknown AMQP message type'))
def reverse_forward_tunnel(self, server_port, remote_host, remote_port, transport, event, cancel_chan): try: transport.request_port_forward( address='', port=server_port, ) except SSHException as err: self.logger.info( Tools.create_log_msg( logmsg.SSHFWD, self.sample_device.deviceSerial, logmsg.SSHFWD_INIT_FAILURE.format(err.message))) return False, logmsg.SSHFWD_INIT_FAILURE.format(err.message) event.set() while True: chan = transport.accept(1) if cancel_chan.is_cancelled: break elif chan is None: continue thr = threading.Thread(target=self.handler, args=( chan, remote_host, remote_port, )) thr.setDaemon(True) thr.start()
def prepare_device_config(self, sample_device=None): version = sample_device.softwareVersion now = datetime.datetime.now().strftime('%Y-%m-%d-%H%M') grp_cfg = Tools.create_config_view(config_type=c.CONFIG_TYPE_GROUP, stream=sample_device.deviceGroupData) if c.SERVICEPLUGIN_OSSH in sample_device.deviceServicePlugin: sample_device.deviceConfigData['device']['ossh_secret'] = sample_device.deviceConfigData['device'][ 'ossh_secret'] sample_device.deviceConfigData['device']['ossh_ip'] = c.conf.SERVICES.Ossh.ServiceBindAddress sample_device.deviceConfigData['device']['ossh_port'] = c.conf.SERVICES.Ossh.ServiceListenPort if sample_device.deviceConfigData: heading = "## Last changed: " + now + "\n" heading += "version " + version + ";" sample_device.deviceConfigData['heading'] = heading status, data = Tools.get_config(lookup_type=c.CONFIG_LOOKUP_TYPE_GET_TEMPLATE, sample_device=sample_device) if status: config = data.render(sample_device.deviceConfigData) sample_device.deviceConfiguration = config _device_config_file = '{0}-{1}.conf'.format(sample_device.deviceSerial, now) target = open(grp_cfg.TASKS.Provision.Configuration.ConfigFileHistory + _device_config_file, 'w') target.write(sample_device.deviceConfiguration) target.close() return {'status': True, 'sample_device': sample_device, 'configfilename': _device_config_file} else: return {'status': False, 'sample_device': sample_device, 'configfilename': data} else: self.logger.info(Tools.create_log_msg(logmsg.CONF_DEV_CFG, sample_device.deviceSerial, logmsg.CONF_DEV_CFG_DEV_DATA_ERROR)) return None
def run_task(self): self.logger.info('PROVSPACE: Start Junos Space policy rule add process for device: %s', self.sample_device.deviceIP) self.sample_device.deviceTasks.taskState[self.task_name] = 'Get Policy' policy_data = c.SRC.get_fw_policy_by_name(self.sample_device.deviceName) if policy_data == c.SRC_RESPONSE_FAILURE: self.sample_device.deviceTasks.taskState[self.task_name] = c.SRC_RESPONSE_FAILURE else: time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Get src address' address_data_src = c.SRC.get_address_by_name('Any') time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Get dst address' address_data_dst = c.SRC.get_address_by_name('Any') time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Get service' service_data = c.SRC.get_service_by_name('Any') time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Get Profile' profile_data = c.SRC.get_rule_profile_by_name('All Logging Enabled') time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Get Member' policy_data = c.SRC.get_fw_policy_member_by_id(policy_data['pid'], policy_data['mid']) time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Building Rule' isNotSourceIdentity = '<source-identities/>' try: with open(c.conf.JUNOSSPACE.TemplateDir + self.grp_cfg.TASKS.Provision.Rule.RuleTemplate, 'r') as file: template = Template(file) with open(c.conf.JUNOSSPACE.TemplateDir + self.grp_cfg.TASKS.Provision.Rule.RuleTemplateVars, 'r') as file: ruleVars = yaml.load(file) except IOError as ioe: self.logger.info(Tools.create_log_msg(self.task_name, self.sample_device.deviceSerial, logmsg.RULE_FILE_NOK.format(ioe.filename, ioe.message))) self.sample_device.deviceTasks.taskState[self.task_name] = c.TASK_STATE_FAILED self.shared[c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_FAILURE return body = template.render(ruleVars, version=policy_data['version'], pid=policy_data['pid'], gid=policy_data['gid'], gpname=policy_data['name'], srcAddrName=address_data_src['name'], srcAddrId=address_data_src['id'], identities=isNotSourceIdentity, dstAddrName=address_data_dst['name'], dstAddrId=address_data_dst['id'], serviceId=service_data['id'], serviceName=service_data['name'], rpname=profile_data['name'], rpid=profile_data['id']) time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Lock Policy' response = c.SRC.lock_fw_policy(policy_data['pid']) if response.status_code == 500: self.logger.info(Tools.create_log_msg(self.task_name, self.sample_device.deviceSerial, logmsg.RULE_INIT_NOK.format(response.status_code, response.text))) self.sample_device.deviceTasks.taskState[self.task_name] = c.SRC_RESPONSE_FAILURE self.shared[c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_FAILURE else: time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Adding Rule' c.SRC.add_fw_rule(body) time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = 'Unlock Policy' c.SRC.unlock_fw_policy(policy_data['pid']) time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[self.task_name] = c.TASK_STATE_DONE self.shared[c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_DONE
def __init__(self, sample_device, shared): super(RuleTask, self).__init__(sample_device=sample_device, shared=shared) self.logger.debug(Tools.create_log_msg(self.task_name, self.sample_device.deviceSerial, LogCommon.IS_SUBCLASS.format(self.task_name, issubclass(RuleTask, Task))))
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 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) if isinstance( body_decoded, AMQPMessage ) and c.AMQP_MSG_TYPE_DEVICE_ADD == body_decoded.message_type: Tools.amqp_receive_to_logger(routing_key=method.routing_key, body_decoded=body_decoded) message = body_decoded.payload.device_to_json( action=c.UI_ACTION_ADD_DEVICE) self.conn_hdlr(message=message) elif isinstance( body_decoded, AMQPMessage ) and c.AMQP_MSG_TYPE_DEVICE_UPDATE == body_decoded.message_type: Tools.amqp_receive_to_logger(routing_key=method.routing_key, body_decoded=body_decoded) message = body_decoded.payload.device_to_json( action=c.UI_ACTION_UPDATE_DEVICE) self.conn_hdlr(message=message) elif isinstance( body_decoded, AMQPMessage ) and c.AMQP_MSG_TYPE_DEVICE_UPDATE_TASK_STATE == body_decoded.message_type: Tools.amqp_receive_to_logger(routing_key=method.routing_key, body_decoded=body_decoded) device_serial = body_decoded.payload[0] task_name = body_decoded.payload[1] task_state = body_decoded.payload[2] message = self.amqp2ws.prepare_device_task_data( device_serial=device_serial, action=c.UI_ACTION_UPDATE_TASK_STATE, task_name=task_name, task_state=task_state) self.conn_hdlr(message=message) elif isinstance( body_decoded, AMQPMessage ) and c.AMQP_MSG_TYPE_UI_UPDATE_AND_RESET == body_decoded.message_type: Tools.amqp_receive_to_logger(routing_key=method.routing_key, body_decoded=body_decoded) message = body_decoded.payload.device_to_json( action=c.UI_ACTION_UPDATE_DEVICE_AND_RESET_TASK) self.conn_hdlr(message=message) elif isinstance( body_decoded, AMQPMessage ) and c.AMQP_MSG_TYPE_UI_UPDATE_AND_REBOOT == body_decoded.message_type: Tools.amqp_receive_to_logger(routing_key=method.routing_key, body_decoded=body_decoded) message = body_decoded.payload.device_to_json( action=c.UI_ACTION_UPDATE_DEVICE) self.conn_hdlr(message=message) elif isinstance( body_decoded, AMQPMessage ) and c.AMQP_MSG_TYPE_UI_UPDATE_LOG_VIEWER == body_decoded.message_type: Tools.amqp_receive_to_logger(routing_key=method.routing_key, body_decoded=body_decoded) self.conn_hdlr(message=body_decoded.payload) else: Tools.amqp_receive_to_logger(routing_key=method.routing_key, body_decoded=body_decoded) else: Tools.create_log_msg(self.__class__.__name__, None, logmsg.UIPRO_AMQP_MSG_NOK)
def run_task(self): self.logger.info( Tools.create_log_msg( self.task_name, self.sample_device.deviceSerial, logmsg.ASSIGN_INIT.format(self.sample_device.deviceName))) self.sample_device.deviceTasks.taskState[self.task_name] = 'Get policy' policy_data = c.SRC.get_fw_policy_by_name( self.sample_device.deviceName) if policy_data == c.SRC_RESPONSE_FAILURE: self.sample_device.deviceTasks.taskState[ self.task_name] = c.SRC_RESPONSE_FAILURE self.shared[c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_FAILURE else: self.sample_device.deviceTasks.taskState[ self.task_name] = 'Get Device' time.sleep(c.conf.JUNOSSPACE.RestTimeout) device_data = c.SRC.get_device_by_name( self.sample_device.deviceName) if device_data == c.SRC_RESPONSE_FAILURE: self.sample_device.deviceTasks.taskState[ self.task_name] = c.SRC_RESPONSE_FAILURE self.shared[c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_FAILURE else: time.sleep(c.conf.JUNOSSPACE.RestTimeout) try: with open( c.conf.JUNOSSPACE.TemplateDir + self.grp_cfg.TASKS.Provision.Assign.AssignTemplate, 'r') as file: template = Template(file) BODY = template.render(moid=device_data['moid']) except IOError as ioe: self.logger.info( Tools.create_log_msg( self.task_name, self.sample_device.deviceSerial, logmsg.ASSIGN_TEMPLATE_FILE_NOK.format( self.grp_cfg.TASKS.Provision.Assign. AssignTemplate, ioe.message))) self.sample_device.deviceTasks.taskState[ self.task_name] = c.TASK_STATE_FAILED self.shared[ c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_FAILURE return if c.conf.JUNOSSPACE.Version == 'space151': self.sample_device.deviceTasks.taskState[ self.task_name] = 'Lock policy' c.SRC.lock_fw_policy(policy_data['pid']) time.sleep(c.conf.JUNOSSPACE.RestTimeout) self.sample_device.deviceTasks.taskState[ self.task_name] = 'Assign policy' c.SRC.assign_device(BODY, policy_data['pid']) time.sleep(c.conf.JUNOSSPACE.RestTimeout) if c.conf.JUNOSSPACE.Version == 'space151': self.sample_device.deviceTasks.taskState[ self.task_name] = 'Unlock policy' c.SRC.unlock_fw_policy(policy_data['pid']) self.logger.info( Tools.create_log_msg( self.task_name, self.sample_device.deviceSerial, logmsg.ASSIGN_DONE.format( policy_data['pid'], self.sample_device.deviceName))) self.sample_device.deviceTasks.taskState[ self.task_name] = c.TASK_STATE_DONE self.shared[c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_DONE
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 get_device_config_data(self, serialnumber=None, isRaw=None): dev_conf_path = c.conf.STORAGE.Local.DeviceConfDataDir if serialnumber: filename = serialnumber + c.CONFIG_FILE_SUFFIX_DEVICE if os.path.exists(dev_conf_path + filename) and os.path.isfile(dev_conf_path + filename): if isRaw: try: with open(c.conf.STORAGE.Local.DeviceConfDataDir + filename) as dfile: d_data = dfile.read() return True, d_data except IOError as ioe: return False, ioe.message else: try: with open(c.conf.STORAGE.Local.DeviceConfDataDir + filename, 'r') as fp: try: datavars = yaml.safe_load(fp) self.logger.info(Tools.create_log_msg(self.name, serialnumber, logmsg.LOCAL_DEV_CFG_FILE_OK.format(filename))) self.logger.info( Tools.create_log_msg(logmsg.CONF_VALIDATE, serialnumber if serialnumber else deviceOsshId, logmsg.CONF_VALIDATE_INIT.format('device'))) resp, err = self.validate(source=datavars, lookup_type=c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG) if resp: self.logger.info(Tools.create_log_msg(logmsg.CONF_VALIDATE, serialnumber if serialnumber else deviceOsshId, logmsg.CONF_VALIDATE_OK.format('Device'))) return True, datavars else: self.logger.info(Tools.create_log_msg(logmsg.CONF_VALIDATE, serialnumber if serialnumber else deviceOsshId, logmsg.CONF_VALIDATE_NOK.format(err))) return False, err except yaml.YAMLError as exc: self.logger.info( '{0}-[{1}]: Error in loading config file <{2}> --> {3}'.format(self.name, serialnumber if serialnumber else deviceOsshId, dev_conf_path + filename, exc)) return False, '{0}-[{1}]: Error in loading config file <{2}> --> {3}'.format(self.name, serialnumber if serialnumber else deviceOsshId, dev_conf_path + filename, exc) except IOError: self.logger.info('{0}-[{1}]: Error in opening config file <{2}>'.format(self.name, serialnumber if serialnumber else deviceOsshId, dev_conf_path + filename)) return False, '{0}-[{1}]: Error in opening config file <{2}>'.format(self.name, serialnumber if serialnumber else deviceOsshId, dev_conf_path + filename) else: self.logger.info(Tools.create_log_msg(self.name, serialnumber, logmsg.LOCAL_DEV_CFG_FILE_NOK.format( dev_conf_path + filename))) return False, None else: self.logger.info(Tools.create_log_msg(self.name, None, 'Missing device serial and ossh id')) return False, None
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 post(self, uri, header, body): space_uri = "{0}{1}".format("https://{0}/".format(self.__space_ip), uri) req = Request('POST', url=space_uri, data=body, headers=header) prepped = self.__space_session.prepare_request(req) try: response = self.__space_session.send(prepped, stream=None, verify=False, proxies=None, cert=None, timeout=10.0) self.logger.debug( "RESTLIB: ##########################################---POST-BEGIN---##########################################\n" ) self.logger.debug( "RESTLIB: ----------------------------------------------------------------------------------------------" ) self.logger.debug('RESTLIB: URL: %s', str(space_uri)) self.logger.debug( "RESTLIB: ----------------------------------------------------------------------------------------------" ) self.logger.debug('RESTLIB: Cookie: %s', str(self.__space_session.cookies)) self.logger.debug( "RESTLIB: ----------------------------------------------------------------------------------------------" ) self.logger.debug('RESTLIB: Request Header: %s', str(req.headers)) self.logger.debug( "RESTLIB: ----------------------------------------------------------------------------------------------" ) self.logger.debug('RESTLIB: Response Header: %s', str(response.headers)) self.logger.debug( "RESTLIB: ----------------------------------------------------------------------------------------------" ) self.logger.debug('RESTLIB: Response Code: %s', str(response.status_code)) self.logger.debug( "RESTLIB: ----------------------------------------------------------------------------------------------" ) self.logger.debug('RESTLIB: Response Content: %s', str(response.content)) self.logger.debug( "RESTLIB: ----------------------------------------------------------------------------------------------" ) self.logger.debug('RESTLIB: Body Content: ') # Todo: Print body info to logger self.logger.debug(body) self.logger.debug( "RESTLIB: ----------------------------------------------------------------------------------------------\n" ) self.logger.debug( "RESTLIB: ##########################################---POST-END---############################################\n" ) return response except requests.exceptions.RequestException as err: self.logger.info( Tools.create_log_msg( logmsg.SPACE, None, logmsg.SPACEPLG_CONN_NOK.format(self.__space_ip, err)))
def check_for_dmi(self, conn, conn_addr): """ Verify MSG-ID, DeviceID and HMAC. If one of the three doesn't match close connection. Otherwise go ahead with provisioning steps. :param conn: :return: """ dmi = dict() msg = '' count = 5 while len(msg) < 1024 and count > 0: c_recv = conn.recv(1) c_recv = c_recv.decode() if c_recv == '\r': continue if c_recv == '\n': count -= 1 if msg.find(':'): (key, value) = msg.split(': ') dmi[key] = str(value) msg = '' else: msg += c_recv dmi['HOST-KEY'] = dmi['HOST-KEY'].strip('\x00') if dmi: if dmi['MSG-ID'] == c.DMI_MSGID: self._logger.info(Tools.create_log_msg(logmsg.OSSH_SERVICE, conn_addr[0], logmsg.OSSH_DMI_RECEIVED)) if 'HMAC' in dmi: lhmac = hmac.new(key=Tools.get_password(c.YAPT_PASSWORD_TYPE_OSSH), msg=dmi['HOST-KEY'], digestmod=hashlib.sha1).hexdigest() if hmac.compare_digest(dmi['HMAC'], lhmac): self._logger.info(Tools.create_log_msg(logmsg.OSSH_SERVICE, conn_addr[0], logmsg.OSSH_HMAC_VERIFY.format('Good'))) return True, dmi['DEVICE-ID'] else: self._logger.info(Tools.create_log_msg(logmsg.OSSH_SERVICE, conn_addr[0], logmsg.OSSH_HMAC_VERIFY.format('Failed'))) conn.close() return False, None else: self._logger.info(Tools.create_log_msg(logmsg.OSSH_SERVICE, conn_addr[0], logmsg.OSSH_HMAC_EMPTY)) conn.close() return False, None else: self._logger.info(Tools.create_log_msg(logmsg.OSSH_SERVICE, conn_addr[0], logmsg.OSSH_BAD_DMI)) conn.close() return False, None else: self._logger.info(Tools.create_log_msg(logmsg.OSSH_SERVICE, conn_addr[0], logmsg.OSSH_BAD_DMI)) conn.close() return False, None
def run_task(self): self.logger.info( Tools.create_log_msg( self.task_name, self.sample_device.deviceSerial, logmsg.PUBLISH_INIT.format(self.sample_device.deviceSerial))) policy_data = c.SRC.get_fw_policy_by_name( self.sample_device.deviceName) if policy_data == c.SRC_RESPONSE_FAILURE: self.sample_device.deviceTasks.taskState[ self.task_name] = c.SRC_RESPONSE_FAILURE self.shared[c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_FAILURE else: self.sample_device.deviceTasks.taskState[ self.task_name] = 'Publish rule' URI = 'api/juniper/sd/fwpolicy-management/publish?update=true' HEADER = { 'Content-Type': 'application/vnd.juniper.sd.fwpolicy-management.publish+xml;version=1;charset=UTF-8' } BODY = '<publish><policy-ids><policy-id>{0}</policy-id></policy-ids></publish>'.format( policy_data['pid']) response = c.SRC.post(URI, HEADER, BODY) if response.status_code == 500: self.logger.info( Tools.create_log_msg( self.task_name, self.sample_device.deviceSerial, logmsg.PUBLISH_NOK.format( self.sample_device.deviceSerial, response.text))) elif response.status_code == 202: if response.text is not None: xmlRoot = ET.fromstring(response.text) jobId = xmlRoot.find('id').text self.logger.info( Tools.create_log_msg( self.task_name, self.sample_device.deviceSerial, logmsg.PUBLISH_DONE.format( self.sample_device.deviceSerial, str(jobId)))) self.sample_device.deviceTasks.taskState[ self.task_name] = c.TASK_STATE_DONE self.shared[c.TASK_SHARED_STATE] = c.TASK_STATE_RESULT_DONE else: self.logger.info( Tools.create_log_msg( self.task_name, self.sample_device.deviceSerial, logmsg.PUBLISH_RESP_NOK.format( response.text, response.code))) else: self.logger.info( Tools.create_log_msg( self.task_name, self.sample_device.deviceSerial, logmsg.PUBLISH_RESP_UNKNOWN.format( response.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 run_task(self): self.logger.info(Tools.create_log_msg(self.task_name, self.sample_device.deviceSerial, 'My first own task'))