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, **params):
self.deviceIP = cherrypy.request.headers['Remote-Addr']
self.sn_nr = params['uid']
status, data = Tools.get_config(
lookup_type=c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG,
serialnumber=self.sn_nr,
deviceOsshId=None)
if status:
try:
self.device_type = data['yapt']['device_type']
self.service_chain = data['yapt']['service_chain']
except KeyError as ke:
self.logger.info('{0} {1}'.format(
logmsg.PHS_SERVICE + ':',
logmsg.PHS_CONF_KEY_ERROR.format(ke.message)))
return
_boostrap_init_file = c.conf.SERVICES.Phs.InitConfPath + self.device_type + '.xml'
if os.path.isfile(_boostrap_init_file):
response = None
try:
env = Environment(autoescape=select_autoescape(['xml']),
loader=FileSystemLoader(
c.conf.SERVICES.Phs.InitConfPath),
trim_blocks=True,
lstrip_blocks=True)
response = env.get_template(self.device_type +
'.xml').render(
serial=self.sn_nr)
except (TemplateNotFound, IOError) as err:
self.logger.info(
Tools.create_log_msg(
logmsg.PHS_SERVICE, self.sn_nr,
logmsg.PHS_TEMPLATE_ERROR.format(
err.errno, err.strerror, err.filename)))
return response
else:
self.logger.info(
Tools.create_log_msg(
logmsg.PHS_SERVICE, self.sn_nr,
logmsg.PHS_BOOSTRAP_FILE_FAILED.format(
_boostrap_init_file)))
else:
self.logger.info(
Tools.create_log_msg(logmsg.PHS_SERVICE, self.sn_nr,
logmsg.PHS_DEV_CONF_FAILED))
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 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 run_task(self):
status_dev_cfg, dev_data_file = Tools.get_config(
lookup_type=c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG_FILE,
sample_device=self.sample_device)
status_template, template_file = Tools.get_config(
lookup_type=c.CONFIG_LOOKUP_TYPE_GET_TEMPLATE_FILE,
sample_device=self.sample_device)
if status_dev_cfg:
if status_template:
loader = DataLoader()
try:
ds = loader.load_from_file(
os.getcwd() + '/' + self.grp_cfg.TASKS.Provision.
Configuration.Ansibleapi.PlaybookPath + self.grp_cfg.
TASKS.Provision.Configuration.Ansibleapi.Playbook)
except AnsibleFileNotFound as afnf:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.PLAYBOOK_NOT_FOUND.format(
afnf))
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.PLAYBOOK_NOT_FOUND.format(afnf))
return
# Dynamic Inventory
inventory = """
[YAPT]
{{ hosts }}
[YAPT:vars]
junos_user={{ junos_user }}
junos_password={{ junos_password }}
template_src={{ template_src }}
template_dst={{ template_dst }}
device_vars={{ device_vars }}
heading={{ heading }}
"""
inventory_template = jinja2.Template(inventory)
'''
## Last changed: 2017-10-16-2139 version 12.1X47-D35.2;
'''
heading = """## Last changed: {0} version {1};
""".format(
datetime.datetime.now().strftime('%Y-%m-%d-%H%M'),
self.sample_device.softwareVersion)
rendered_inventory = inventory_template.render({
'hosts':
self.sample_device.deviceIP,
'junos_user':
c.conf.YAPT.DeviceUsr,
'junos_password':
Tools.get_password(c.YAPT_PASSWORD_TYPE_DEVICE),
'template_src':
template_file,
'template_dst':
os.getcwd() + '/history/' +
self.sample_device.deviceSerial + '-' +
datetime.datetime.now().strftime('%Y-%m-%d-%H%M') +
'.conf',
'device_vars':
dev_data_file,
'heading':
heading
})
self.logger.debug(
Tools.create_log_msg(self.task_name,
self.sample_device.deviceSerial,
rendered_inventory))
# Create a temporary file and write the template string to it
hosts = NamedTemporaryFile(delete=False)
hosts.write(rendered_inventory)
hosts.close()
inventory = InventoryManager(loader=loader, sources=hosts.name)
variable_manager = VariableManager(loader=loader,
inventory=inventory)
Options = namedtuple('Options', [
'listtags', 'listtasks', 'listhosts', 'syntax',
'connection', 'module_path', 'forks', 'remote_user',
'private_key_file', 'ssh_common_args', 'ssh_extra_args',
'sftp_extra_args', 'scp_extra_args', 'become',
'become_method', 'become_user', 'verbosity', 'check',
'diff'
])
options = Options(listtags=False,
listtasks=False,
listhosts=True,
syntax=False,
connection='ssh',
module_path=None,
forks=100,
remote_user=None,
private_key_file=None,
ssh_common_args=None,
ssh_extra_args=None,
sftp_extra_args=None,
scp_extra_args=None,
become=False,
become_method=None,
become_user=None,
verbosity=None,
check=False,
diff=False)
passwords = dict(
vault_pass=Tools.get_password(c.YAPT_PASSWORD_TYPE_DEVICE))
play = Play.load(data=ds[0],
variable_manager=variable_manager,
loader=loader)
results_callback = CallbackModule(
sample_device=self.sample_device,
shared=self.shared,
update_task_state=self.update_task_state)
tqm = None
try:
tqm = TaskQueueManager(
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords,
stdout_callback=results_callback,
)
result = tqm.run(play)
if result > 0:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.ANSIBLE_ERROR)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.ANSIBLE_ERROR)
os.remove(hosts.name)
return
else:
self.update_task_state(
new_task_state=c.TASK_STATE_PROGRESS,
task_state_message=logmsg.PLAYBOOK_FINISHED_SUCCESS
)
self.sample_device.deviceConnection.facts_refresh()
self.sample_device.deviceConnection.facts_refresh(
keys='hostname')
self.sample_device.deviceName = self.sample_device.deviceConnection.facts[
'hostname']
self.update_task_state(
new_task_state=c.TASK_STATE_DONE,
task_state_message=c.TASK_STATE_MSG_DONE)
Tools.emit_log(
task_name=self.task_name,
task_state={
'taskState': self.task_state,
'taskStateMsg': c.TASK_STATE_MSG_DONE
},
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
shared=self.shared,
message=logmsg.PLAYBOOK_FINISHED_SUCCESS,
scope=c.LOGGER_SCOPE_ALL,
level=c.LOGGER_LEVEL_INFO)
os.remove(hosts.name)
except Exception as e:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.PLAYBOOK_ERROR.format(e))
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.PLAYBOOK_ERROR.format(e))
return
finally:
if tqm is not None:
tqm.cleanup()
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.ERROR_DEV_CFG_FILE)
Tools.emit_log(task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.ERROR_DEV_TEMPLATE_FILE.format(
template_file))
else:
self.update_task_state(
new_task_state=c.TASK_STATE_FAILED,
task_state_message=logmsg.ERROR_DEV_CFG_FILE)
Tools.emit_log(
task_name=self.task_name,
sample_device=self.sample_device,
message=logmsg.ERROR_DEV_CFG_FILE.format(dev_data_file))
return
def run_task(self):
cancel_chan = ChannelCancellation()
e = threading.Event()
status, data = Tools.get_config(
lookup_type=c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG,
sample_device=self.sample_device)
if status:
if self.grp_cfg.TASKS.Provision.Cert.PortForwarding:
if self.sample_device.deviceServicePlugin != c.SERVICEPLUGIN_OSSH:
with SCP(self.sample_device.deviceConnection,
progress=False) as scp:
scp.put(c.conf.SERVICES.Ossh.LocalConfigFile,
c.SSHD_PORT_FWD_PATH)
self.logger.info(
Tools.create_log_msg(
self.task_name,
self.sample_device.deviceSerial,
logmsg.CERT_FILE_OK.format(
self.sample_device.deviceSerial)))
self.sample_device.deviceConnection.close()
status, self.sample_device = Tools.create_dev_conn(
self.sample_device)
if status:
thr = threading.Thread(target=self.do_cert_requests,
args=(
data,
e,
cancel_chan,
))
thr.start()
ssh_pfwd = SSHPortForward(
sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
event=e,
cancel_chan=cancel_chan)
ssh_pfwd.init_port_fwd()
else:
return False, 'Error in device connection'
else:
thr = threading.Thread(target=self.do_cert_requests,
args=(
data,
e,
cancel_chan,
))
thr.start()
ssh_pfwd = SSHPortForward(sample_device=self.sample_device,
grp_cfg=self.grp_cfg,
event=e,
cancel_chan=cancel_chan)
ssh_pfwd.init_port_fwd()
else:
self.do_cert_requests(datavars=data, event=None)
else:
self.logger.info(
Tools.create_log_msg(self.task_name,
self.sample_device.deviceSerial,
logmsg.CERT_DEV_DATA_NOK))
