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