def save_positions(workflow_id):
workflow = retrieve(Workflow, id=workflow_id)
for task_id, position in request.json.items():
task = retrieve(Task, id=task_id)
task.positions[workflow.name] = (position['x'], position['y'])
db.session.commit()
return jsonify({'success': True})
def create_other_workflow():
tasks = [
retrieve(Task, name=task_name) for task_name in (
'task_script_napalm_getter',
'task_GET_router8',
)
]
workflow = factory(
Workflow, **{
'name': 'custom_workflow',
'description': 'ReST call, Napalm getters, etc',
'tasks': tasks
})
for i in range(len(tasks) - 1):
factory(
WorkflowEdge, **{
'name': f'{tasks[i].name} -> {tasks[i + 1].name}',
'workflow': workflow,
'type': True,
'source': tasks[i],
'destination': tasks[i + 1]
})
workflow.start_task, workflow.end_task = tasks[0].id, tasks[-1].id
factory(
WorkflowTask, **{
'name': 'task_custom_workflow',
'job': workflow,
'do_not_run': 'y',
'user': retrieve(User, name='cisco')
})
def create_napalm_workflow():
tasks = [
retrieve(Task, name=task_name)
for task_name in ('task_napalm_create_vrf_TEST',
'task_netmiko_check_vrf_TEST',
'task_napalm_rollback',
'task_netmiko_check_no_vrf_TEST')
]
workflow = factory(
Workflow, **{
'name': 'Napalm_VRF_workflow',
'description': 'Create and delete a VRF with Napalm',
'tasks': tasks
})
for i in range(len(tasks) - 1):
factory(
WorkflowEdge, **{
'name': f'{tasks[i].name} -> {tasks[i + 1].name}',
'workflow': workflow,
'type': True,
'source': tasks[i],
'destination': tasks[i + 1]
})
workflow.start_task, workflow.end_task = tasks[0].id, tasks[-1].id
factory(
WorkflowTask, **{
'name': 'task_napalm_VRF_workflow',
'job': workflow,
'do_not_run': 'y',
'user': retrieve(User, name='cisco')
})
def save_pool_objects(pool_id):
pool = retrieve(Pool, id=pool_id)
pool.devices = [
retrieve(Device, id=id) for id in request.form.getlist('devices')
]
pool.links = [retrieve(Link, id=id) for id in request.form.getlist('links')]
db.session.commit()
return jsonify(pool.name)
def add_edge(wf_id, type, source, dest):
source_task = retrieve(Task, id=source)
destination_task = retrieve(Task, id=dest)
workflow_edge = factory(WorkflowEdge, **{
'name': f'{source_task.name} -> {destination_task.name}',
'workflow': retrieve(Workflow, id=wf_id),
'type': type,
'source': source_task,
'destination': destination_task
})
return jsonify(workflow_edge.serialized)
def test_pool_management(user_client):
create_from_file(user_client, 'europe.xls')
user_client.post('/objects/process_pool', data=pool1)
user_client.post('/objects/process_pool', data=pool2)
p1, p2 = retrieve(Pool, name='pool1'), retrieve(Pool, name='pool2')
assert len(p1.devices) == 21
assert len(p1.links) == 20
assert len(p2.devices) == 12
assert len(p2.links) == 4
assert len(Pool.query.all()) == 5
user_client.post(f'/objects/delete_pool/{p1.id}')
user_client.post(f'/objects/delete_pool/{p2.id}')
assert len(Pool.query.all()) == 3
def scheduler(workflow_id=None):
data = request.form.to_dict()
data['job'] = retrieve(Job, id=data['job'])
data['devices'] = [
retrieve(Device, id=id) for id in request.form.getlist('devices')
]
data['pools'] = [
retrieve(Pool, id=id) for id in request.form.getlist('pools')
]
data['user'] = current_user
cls = WorkflowTask if data['job'].type == 'workflow' else ScriptTask
task = factory(cls, **data)
return jsonify(task.serialized)
def get_logs(device_id):
device = retrieve(Device, id=device_id)
device_logs = [
l.content for l in Log.query.all()
if l.source == device.ip_address
]
return jsonify('\n'.join(device_logs))
def test_link_deletion(user_client):
create_from_file(user_client, 'europe.xls')
for link_name in links:
link = retrieve(Link, name=link_name)
user_client.post(f'/objects/delete/link/{link.id}')
assert len(Device.query.all()) == 33
assert len(Link.query.all()) == 38
def test_device_deletion(user_client):
create_from_file(user_client, 'europe.xls')
for device_name in routers:
device = retrieve(Device, name=device_name)
user_client.post(f'/objects/delete/device/{device.id}')
assert len(Device.query.all()) == 18
assert len(Link.query.all()) == 18
def compare_logs(task_id):
task = retrieve(Task, id=task_id)
results = {
'devices': [device.name for device in task.devices],
'versions': list(task.logs)
}
return jsonify(results)
def get_script(script_type, script_id):
script = retrieve(Script, id=script_id)
properties = type_to_properties[script_type]
script_properties = {
property: getattr(script, property)
for property in properties
}
return jsonify(script_properties)
def factory(cls, **kwargs):
instance = retrieve(cls, name=kwargs['name'])
if instance:
instance.update(**kwargs)
else:
instance = cls(**kwargs)
db.session.add(instance)
db.session.commit()
return instance
def create_netmiko_tasks():
scripts = [
retrieve(Script, name=script_name)
for script_name in ('netmiko_create_vrf_TEST',
'netmiko_check_vrf_TEST',
'netmiko_delete_vrf_TEST',
'netmiko_check_no_vrf_TEST')
]
for script in scripts:
factory(
ScriptTask, **{
'name': f'task_{script.name}',
'devices': [retrieve(Device, name='router8')],
'waiting_time': 3 if script.name == 'delete_vrf_TEST' else 0,
'job': script,
'do_not_run': 'y',
'user': retrieve(User, name='cisco')
})
def create_napalm_tasks():
device = retrieve(Device, name='router8')
user = retrieve(User, name='cisco')
factory(
ScriptTask, **{
'name': 'task_napalm_create_vrf_TEST',
'job': retrieve(Script, name='napalm_create_vrf_TEST'),
'devices': [device],
'do_not_run': 'y',
'user': user
})
factory(
ScriptTask, **{
'name': 'task_napalm_rollback',
'job': retrieve(Script, name='Napalm Rollback'),
'devices': [device],
'do_not_run': 'y',
'user': user
})
def get_object(obj_type, obj_id):
if obj_type == 'device':
cls, properties = Device, device_public_properties
else:
cls, properties = Link, link_public_properties
obj = retrieve(cls, id=obj_id)
obj_properties = {
property: str(getattr(obj, property))
for property in properties
}
return jsonify(obj_properties)
def putty_connection(name):
current_os, device = platform_system(), retrieve(Device, name=name)
username, password, _ = get_credentials(device)
if current_os == 'Windows':
path_putty = join(current_app.path, 'applications', 'putty.exe')
ssh = f'{path_putty} -ssh {username}@{device.ip_address} -pw {password}'
Popen(ssh.split())
else:
sshpass = f'"sshpass -p {password} ssh {username}@{device.ip_address}"'
os_system(f'gnome-terminal -- /bin/bash -c {sshpass}')
return jsonify({'success': True})
def create_other_tasks():
device = retrieve(Device, name='router8')
user = retrieve(User, name='cisco')
factory(
ScriptTask, **{
'name': 'task_script_napalm_getter',
'waiting_time': '0',
'job': retrieve(Script, name='script_napalm_getter'),
'devices': [device],
'do_not_run': 'y',
'user': user
})
factory(
ScriptTask, **{
'name': 'task_GET_router8',
'job': retrieve(Script, name='GET_router8'),
'devices': [],
'do_not_run': 'y',
'user': user
})
def test_user_management(user_client):
for user in ('user1', 'user2', 'user3'):
dict_user = {
'name': user,
'email': '{}@test.com'.format(user),
'access_rights': 'Read-only',
'password': user,
}
user_client.post('/admin/process_user', data=dict_user)
assert len(User.query.all()) == 5
# user deletion
user1 = retrieve(User, name='user1')
user_client.post('/admin/delete_{}'.format(user1.id))
assert len(User.query.all()) == 4
def process_kwargs(app, **kwargs):
if 'source' in kwargs:
source = retrieve(Device, name=kwargs.pop('source'))
destination = retrieve(Device, name=kwargs.pop('destination'))
kwargs.update({
'source_id': source.id,
'destination_id': destination.id,
'source': source,
'destination': destination
})
else:
if app.production:
app.vault_client.write(
f'secret/data/device/{kwargs["name"]}',
data={
'username': kwargs.pop('username', ''),
'password': kwargs.pop('password', ''),
'secret_password': kwargs.pop('secret_password', '')
}
)
else:
for arg in ('password', 'secret_password'):
kwargs[arg] = cisco_type7.hash(kwargs.get(arg, ''))
return Link if 'source' in kwargs else Device, kwargs
def connection(name):
current_os, device = system(), retrieve(Device, name=name)
username, password, _ = get_credentials(device)
if current_os == 'Windows':
path_putty = join(current_app.path, 'applications', 'putty.exe')
ssh = f'{path_putty} -ssh {username}@{device.ip_address} -pw {password}'
Popen(ssh.split())
else:
path_gotty = join(current_app.path, 'applications', 'gotty')
if current_app.config['GOTTY_AUTHENTICATION']:
cmd = f'sshpass -p {password} ssh {username}@{device.ip_address}'
else:
cmd = f'ssh {username}@{device.ip_address}'
port_index = current_app.gotty_increment % current_app.gotty_modulo
current_app.gotty_increment += 1
port = current_app.config['GOTTY_ALLOWED_PORTS'][port_index]
Popen(f'{path_gotty} -w -p {port} {cmd}'.split())
return jsonify({'device': device.name, 'port': port})
def workflow_editor(workflow_id=None):
add_existing_task_form = AddExistingTaskForm(request.form)
workflow_editor_form = WorkflowEditorForm(request.form)
workflow_editor_form.workflow.choices = Workflow.choices()
workflow = retrieve(Workflow, id=workflow_id)
scheduling_form = SchedulingForm(request.form)
scheduling_form.job.choices = Job.choices()
scheduling_form.devices.choices = Device.choices()
scheduling_form.pools.choices = Pool.choices()
add_existing_task_form.task.choices = Task.choices()
return render_template(
'workflow_editor.html',
add_existing_task_form=add_existing_task_form,
workflow_editor_form=workflow_editor_form,
scheduling_form=scheduling_form,
compare_form=CompareForm(request.form),
names=pretty_names,
workflow=workflow.serialized if workflow_id else None
)
def create_script(script_type):
script = retrieve(Script, name=request.form['name'])
form = dict(request.form.to_dict())
form['getters'] = request.form.getlist('getters')
if not script:
if script_type in ('netmiko_config', 'napalm_config'):
if form['content_type'] != 'simple':
file = request.files['file']
filename = secure_filename(file.filename)
if allowed_file(filename, {'yaml', 'yml'}):
parameters = yaml_load(file.read())
template = Template(form['content'])
form['content'] = ''.join(template.render(**parameters))
elif script_type == 'file_transfer':
source_file_name = form['source_file']
source_file_path = join(current_app.path, 'file_transfer',
source_file_name)
form['source_file'] = source_file_path
return jsonify(factory(type_to_class[script_type], **form).serialized)
def job(self, runtime, workflow=None):
start_task = retrieve(Task, id=self.workflow.start_task)
if not start_task:
return False, {runtime: 'No start task in the workflow.'}
layer, visited = {start_task}, set()
results = {}
while layer:
new_layer = set()
for task in layer:
visited.add(task)
task_results = task.job(runtime, workflow)
success = task_results['success']
if task.id == self.workflow.end_task:
results['success'] = success
for neighbor in task.task_neighbors(self.workflow, success):
if neighbor not in visited:
new_layer.add(neighbor)
results[task.name] = task_results
sleep(task.waiting_time)
layer = new_layer
self.logs[runtime] = results
db.session.commit()
return results
def job(task_name, runtime):
with scheduler.app.app_context():
task = retrieve(Task, name=task_name)
workflow = task.workflow if task.type == 'WorkflowTask' else None
task.job(runtime, workflow)
def get_task(task_id):
return jsonify(retrieve(Task, id=task_id).serialized)
def add_to_workflow(workflow_id):
workflow = retrieve(Workflow, id=workflow_id)
task = retrieve(Task, id=request.form['task'])
task.workflows.append(workflow)
db.session.commit()
return jsonify(task.serialized)
def run_task(task_id):
task = retrieve(Task, id=task_id)
task.schedule(run_now=True)
return jsonify(task.serialized)
def get_diff(task_id, v1, v2, n1, n2):
task = retrieve(Task, id=task_id)
first = str_dict(task.logs[v1]['logs'][n1]).splitlines()
second = str_dict(task.logs[v2]['logs'][n2]).splitlines()
opcodes = SequenceMatcher(None, first, second).get_opcodes()
return jsonify({'first': first, 'second': second, 'opcodes': opcodes})
def show_logs(task_id):
return jsonify(str_dict(retrieve(Task, id=task_id).logs))
