def task_management():
if 'compare' in request.form:
n1, n2 = request.form['first_node'], request.form['second_node']
t1, t2 = request.form['first_version'], request.form['second_version']
task = get_obj(db, Task, name=request.form['task_name'])
# get the two versions of the logs
v1 = str_dict(task.logs[t1][n1]).splitlines()
v2 = str_dict(task.logs[t2][n2]).splitlines()
print(v1, v2)
return render_template(
'compare.html',
ndiff='\n'.join(ndiff(v1, v2)),
unified_diff='\n'.join(unified_diff(v1, v2)),
)
tasks = Task.query.all()
form_per_task = {}
for task in filter(lambda t: t.recurrent, tasks):
form = CompareForm(request.form)
form.first_node.choices = [(i, i) for (i, _, _, _) in task.nodes]
form.second_node.choices = form.first_node.choices
versions = [(v, v) for v in tuple(task.logs)]
form.first_version.choices = form.second_version.choices = versions
form_per_task[task.name] = form
# task.logs is a dictionnary and we need to keep that way, but for properly
# outputtng it's content, we will use str_dict
log_per_task = {task.name: str_dict(task.logs) for task in tasks}
return render_template('task_management.html',
tasks=tasks,
log_per_task=log_per_task,
form_per_task=form_per_task)
def get_diff(name, v1, v2, n1, n2, s1, s2):
task = get_obj(Task, name=name)
first = str_dict(task.logs[v1][s1][n1]).splitlines()
second = str_dict(task.logs[v2][s2][n2]).splitlines()
opcodes = SequenceMatcher(None, first, second).get_opcodes()
return jsonify({
'first': first,
'second': second,
'opcodes': opcodes,
})
def job(self, args):
task, node, results = args
dict_result = {}
try:
driver = get_network_driver(node.operating_system)
napalm_driver = driver(
hostname=node.ip_address,
username=task.user.name,
password=cisco_type7.decode(task.user.password),
optional_args={'secret': node.secret_password}
)
napalm_driver.open()
for getter in self.getters:
try:
dict_result[getter] = str_dict(getattr(napalm_driver, getter)())
except Exception as e:
dict_result[getter] = '{} could not be retrieve because of {}'.format(getter, e)
napalm_driver.close()
except Exception as e:
dict_result['error'] = 'getters process did not work because of {}'.format(e)
success = False
else:
success = True
results[node.name] = dict_result
return success
def job(self, args):
task, node, results = args
success, outputs = True, {}
try:
netmiko_handler = ConnectHandler(
device_type=self.driver,
ip=node.ip_address,
username=task.user.name,
password=cisco_type7.decode(task.user.password),
secret=node.secret_password
)
for i in range(1, 4):
command = getattr(self, 'command' + str(i))
if not command:
continue
output = netmiko_handler.send_command(command)
pattern = getattr(self, 'pattern' + str(i))
result = 'Output: {}\n\nExpected pattern: {}'.format(output, pattern)
outputs[command] = result
if pattern not in output:
success = False
except Exception as e:
results[node.name] = 'netmiko did not work because of {}'.format(e)
success = False
results[node.name] = str_dict(outputs)
try:
netmiko_handler.disconnect()
except Exception:
pass
return success
def napalm_getters_job(getters, username, password, nodes_info):
napalm_output = []
for ip_address, driver in nodes_info:
try:
napalm_driver = napalm_connection(
ip_address,
username,
password,
driver,
{'secret': 'cisco'}
)
napalm_output.append('\n{}\n'.format(ip_address))
for getter in getters:
try:
output = str_dict(getattr(napalm_driver, getter)())
print(output)
except Exception as e:
output = '{} could not be retrieve because of {}'.format(getter, e)
print(output)
napalm_output.append(output)
except Exception as e:
output = 'could not be retrieve because of {}'.format(e)
napalm_output.append(output)
print(output)
return napalm_output
def napalm_getters_process(kwargs):
try:
driver = get_network_driver(kwargs['driver'])
napalm_driver = driver(hostname=kwargs['ip_address'],
username=kwargs['username'],
password=kwargs['password'],
optional_args={'secret': kwargs['secret']})
napalm_driver.open()
for getter in kwargs['getters']:
try:
result = str_dict(getattr(napalm_driver, getter)())
except Exception as e:
result = '{} could not be retrieve because of {}'.format(
getter, e)
napalm_driver.close()
except Exception as e:
result = 'getters process did not work because of {}'.format(e)
kwargs['results'][kwargs['name']] = result
def napalm_getters_job(name, getters, username, password, nodes_info):
job_time = str(datetime.now())
task = db.session.query(Task)\
.filter_by(name=name)\
.first()
task.logs[job_time] = {}
for name, ip_address, driver, secret in nodes_info:
try:
napalm_driver = napalm_connection(ip_address, username, password,
driver, secret)
for getter in getters:
try:
result = str_dict(getattr(napalm_driver, getter)())
except Exception as e:
result = '{} could not be retrieve because of {}'.format(
getter, e)
except Exception as e:
result = 'could not be retrieve because of {}'.format(e)
task.logs[job_time][name] = result
db.session.commit()
def show_logs(name):
task = get_obj(Task, name=name)
return jsonify(str_dict(task.logs))
def get_compare(name, v1, v2, n1, n2, s1, s2):
task = get_obj(Task, name=name)
res1 = str_dict(task.logs[v1][s1][n1]).splitlines()
res2 = str_dict(task.logs[v2][s2][n2]).splitlines()
return jsonify('\n'.join(ndiff(res1, res2)),
'\n'.join(unified_diff(res1, res2)))
