def create_default_services():
for service in ({
'type': service_classes['swiss_army_knife_service'],
'name': 'Start',
'description': 'Start point of a workflow',
'hidden': True
}, {
'type': service_classes['swiss_army_knife_service'],
'name': 'End',
'description': 'End point of a workflow',
'hidden': True
}, {
'type': service_classes['configure_bgp_service'],
'name': 'napalm_configure_bgp_1',
'description': 'Configure BGP Peering with Napalm',
'devices': [fetch(Device, name='Washington')],
'local_as': 100,
'loopback': 'Lo100',
'loopback_ip': '100.1.1.1',
'neighbor_ip': '100.1.2.1',
'remote_as': 200,
'vrf_name': 'configure_BGP_test',
'waiting_time': 0
}):
factory(service.pop('type'), **service)
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 create_default_user():
factory(
User, **{
'name': 'cisco',
'email': '*****@*****.**',
'password': '******'
})
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_payload_transfer_workflow():
services = []
for service in [{
'name': 'GET_Washington',
'type': service_classes['rest_call_service'],
'description': 'Use GET ReST call on Washington',
'username': '******',
'password': '******',
'waiting_time': 0,
'devices': [fetch(Device, name='Washington')],
'content_match': '',
'call_type': 'GET',
'url': 'http://127.0.0.1:5000/rest/object/device/Washington',
'payload': ''
}] + [{
'name': f'{getter}',
'type': service_classes['napalm_getters_service'],
'description': f'Getter: {getter}',
'waiting_time': 0,
'devices': [fetch(Device, name='Washington')],
'driver': 'eos',
'content_match': '',
'getters': [getter]
} for getter in ('get_facts', 'get_interfaces', 'get_interfaces_ip',
'get_config')
] + [{
'name': 'process_payload1',
'type': service_classes['swiss_army_knife_service'],
'description': 'Process Payload in example workflow',
'waiting_time': 0,
'devices': [fetch(Device, name='Washington')]
}]:
instance = factory(service.pop('type'), **service)
services.append(instance)
workflow = factory(
Workflow, **{
'name': 'payload_transfer_workflow',
'description': 'ReST call, Napalm getters, etc',
'vendor': 'Arista',
'operating_system': 'eos'
})
workflow.jobs.extend(services)
# create workflow edges with following schema:
positions = [(-20, 0), (50, 0), (-5, 0), (-5, -10), (15, 10), (15, -10),
(30, -10), (30, 0)]
for index, (x, y) in enumerate(positions):
job = workflow.jobs[index]
job.positions['payload_transfer_workflow'] = x * 10, y * 10
edges = [(0, 2), (2, 3), (2, 4), (3, 5), (5, 6), (6, 7), (4, 7), (7, 1)]
for x, y in edges:
factory(
WorkflowEdge, **{
'name': f'{workflow.name} {x} -> {y}',
'workflow': workflow,
'type': True,
'source': workflow.jobs[x],
'destination': workflow.jobs[y]
})
def create_default_users():
factory(
User, **{
'name': 'admin',
'email': '*****@*****.**',
'password': '******',
'permissions': ['Admin']
})
def create_napalm_script():
factory(
NapalmConfigScript, **{
'name': 'napalm_create_vrf_TEST',
'description': 'Create a VRF "TEST" with Napalm',
'vendor': 'Cisco',
'operating_system': 'IOS',
'content_type': 'simple',
'action': 'load_merge_candidate',
'content': 'ip vrf TEST'
})
def create_default_pools():
for pool in ({
'name': 'All objects'
}, {
'name': 'Devices only',
'link_name': '^$',
'link_name_regex': True
}, {
'name': 'Links only',
'device_name': '^$',
'device_name_regex': True
}):
factory(Pool, **pool)
def create_default_network_topology(app):
with open(join(app.path, 'projects', 'usa.xls'), 'rb') as f:
book = open_workbook(file_contents=f.read())
for object_type in ('Device', 'Link'):
try:
sheet = book.sheet_by_name(object_type)
except XLRDError:
continue
properties = sheet.row_values(0)
for row_index in range(1, sheet.nrows):
values = dict(zip(properties, sheet.row_values(row_index)))
cls, kwargs = process_kwargs(app, **values)
factory(cls, **kwargs).serialized
db.session.commit()
def query_netbox():
nb = netbox_api(
request.form['netbox_address'],
token=request.form['netbox_token']
)
for device in nb.dcim.devices.all():
device_ip = device.primary_ip4 or device.primary_ip6
factory(Device, **{
'name': device.name,
'ip_address': str(device_ip).split('/')[0],
'subtype': request.form['netbox_type'],
'longitude': 0.,
'latitude': 0.
})
return jsonify({'success': True})
def create_napalm_workflow():
services = []
for service in ({
'type': service_classes['napalm_configuration_service'],
'name': 'napalm_create_vrf_test',
'description': 'Create a VRF "test" with Napalm',
'waiting_time': 0,
'devices': [fetch(Device, name='Washington')],
'driver': 'eos',
'vendor': 'Arista',
'operating_system': 'eos',
'content_type': 'simple',
'action': 'load_merge_candidate',
'content': 'vrf definition test\n'
}, {
'type': service_classes['napalm_rollback_service'],
'name': 'Napalm eos Rollback',
'driver': 'eos',
'description': 'Rollback a configuration with Napalm eos',
'devices': [fetch(Device, name='Washington')],
'waiting_time': 0
}):
instance = factory(service.pop('type'), **service)
services.append(instance)
services.insert(1, fetch(Job, name='netmiko_check_vrf_test'))
services.append(fetch(Job, name=f'netmiko_check_no_vrf_test'))
workflow = factory(
Workflow, **{
'name': 'Napalm_VRF_workflow',
'description': 'Create and delete a VRF with Napalm',
'vendor': 'Arista',
'operating_system': 'eos'
})
workflow.jobs.extend(services)
edges = [(0, 2), (2, 3), (3, 4), (4, 5), (5, 1)]
for x, y in edges:
factory(
WorkflowEdge, **{
'name': f'{workflow.name} {x} -> {y}',
'workflow': workflow,
'type': True,
'source': workflow.jobs[x],
'destination': workflow.jobs[y]
})
positions = [(-20, 0), (20, 0), (0, -15), (0, -5), (0, 5), (0, 15)]
for index, (x, y) in enumerate(positions):
workflow.jobs[index].positions['Napalm_VRF_workflow'] = x * 10, y * 10
def create_netmiko_scripts():
for script in (
{
'type': NetmikoConfigScript,
'name': 'netmiko_create_vrf_TEST',
'description': 'Create a VRF "TEST" with Netmiko',
'vendor': 'Cisco',
'operating_system': 'IOS',
'content_type': 'simple',
'driver': 'cisco_ios',
'global_delay_factor': '1.0',
'content': 'ip vrf TEST'
},
{
'type': NetmikoValidationScript,
'name': 'netmiko_check_vrf_TEST',
'description': 'Check that the vrf "TEST" is configured',
'vendor': 'Cisco',
'operating_system': 'IOS',
'driver': 'cisco_ios',
'command1': 'show ip vrf',
'content_match1': 'TEST'
},
{
'type': NetmikoConfigScript,
'name': 'netmiko_delete_vrf_TEST',
'description': 'Delete VRF "TEST"',
'vendor': 'Cisco',
'operating_system': 'IOS',
'content_type': 'simple',
'driver': 'cisco_ios',
'global_delay_factor': '1.0',
'content': 'no ip vrf TEST'
},
{
'type': NetmikoValidationScript,
'name': 'netmiko_check_no_vrf_TEST',
'description': 'Check that the vrf "TEST" is NOT configured',
'vendor': 'Cisco',
'operating_system': 'IOS',
'driver': 'cisco_ios',
'command1': 'show ip vrf',
'content_match1': '^((?!TEST).)*$',
'content_match_regex1': 'y'
},
):
factory(script.pop('type'), **script)
def create_other_scripts():
factory(
NapalmGettersScript, **{
'name': 'script_napalm_getter',
'description': 'Getters: facts / Interfaces / Interfaces IP',
'content_match': '',
'getters': ['get_facts', 'get_interfaces', 'get_interfaces_ip']
})
factory(
RestCallScript, **{
'name': 'GET_router8',
'description': 'Use GET ReST call on router8',
'content_match': '',
'call_type': 'GET',
'url': 'http://127.0.0.1:5000/rest/object/device/router8',
'payload': ''
})
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 add_edge(wf_id, type, source, dest):
workflow_edge = factory(
WorkflowEdge, **{
'name': f'{wf_id}-{type}:{source}->{dest}',
'workflow': fetch(Workflow, id=wf_id),
'type': type == 'true',
'source': fetch(Job, id=source),
'destination': fetch(Job, id=dest)
})
return jsonify(workflow_edge.serialized)
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 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 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 edit_workflow():
form = dict(request.form.to_dict())
for property in boolean_properties:
if property not in form:
form[property] = 'off'
form['devices'] = [
fetch(Device, id=id) for id in request.form.getlist('devices')
]
form['pools'] = [
fetch(Pool, id=id) for id in request.form.getlist('pools')
]
return jsonify(factory(Workflow, **form).serialized)
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 query_opennms():
parameters = db.session.query(Parameters).one()
login, password = parameters.opennms_login, request.form['password']
parameters.update(**request.form.to_dict())
db.session.commit()
json_devices = http_get(
parameters.opennms_devices,
headers={'Accept': 'application/json'},
auth=(login, password)
).json()['node']
devices = {
device['id']:
{
'name': device.get('label', device['id']),
'description': device['assetRecord'].get('description', ''),
'location': device['assetRecord'].get('building', ''),
'vendor': device['assetRecord'].get('manufacturer', ''),
'model': device['assetRecord'].get('modelNumber', ''),
'operating_system': device.get('operatingSystem', ''),
'os_version': device['assetRecord'].get('sysDescription', ''),
'longitude': device['assetRecord'].get('longitude', 0.),
'latitude': device['assetRecord'].get('latitude', 0.),
'subtype': request.form['subtype']
} for device in json_devices
}
for device in list(devices):
link = http_get(
f'{parameters.opennms_rest_api}/nodes/{device}/ipinterfaces',
headers={'Accept': 'application/json'},
auth=(login, password)
).json()
for interface in link['ipInterface']:
if interface['snmpPrimary'] == 'P':
devices[device]['ip_address'] = interface['ipAddress']
factory(Device, **devices[device])
db.session.commit()
return jsonify({'success': True})
def import_topology():
objects, file = defaultdict(list), request.files['file']
if allowed_file(secure_filename(file.filename), {'xls', 'xlsx'}):
book = open_workbook(file_contents=file.read())
for object_type in ('Device', 'Link'):
try:
sheet = book.sheet_by_name(object_type)
except XLRDError:
continue
properties = sheet.row_values(0)
for row_index in range(1, sheet.nrows):
values = dict(zip(properties, sheet.row_values(row_index)))
cls, kwargs = process_kwargs(app, **values)
objects[object_type].append(factory(cls, **kwargs).serialized)
db.session.commit()
return jsonify(objects)
def save_service(cls_name):
form = dict(request.form.to_dict())
form['devices'] = [
fetch(Device, id=id) for id in request.form.getlist('devices')
]
form['pools'] = [
fetch(Pool, id=id) for id in request.form.getlist('pools')
]
for key in request.form:
if property_types.get(key, None) == list:
form[key] = request.form.getlist(key)
for property in boolean_properties:
if property not in form:
form[property] = 'off'
try:
return jsonify(factory(service_classes[cls_name], **form).serialized)
except JSONDecodeError:
return jsonify('JSONDecodeError')
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 process_user():
user_data = request.form.to_dict()
user_data['permissions'] = request.form.getlist('permissions')
return jsonify(factory(User, **user_data).serialized)
def create_new_user():
user_data = request.form.to_dict()
if 'permissions' in user_data:
abort(403)
return jsonify(factory(User, **user_data).serialized)
def post(self, cls_name):
return factory(**request.get_json(force=True, silent=True)).serialized
def save_log_rule():
tasks = [retrieve(Task, id=id) for id in request.form.getlist('tasks')]
log_rule = factory(LogRule, **request.form.to_dict())
log_rule.tasks = tasks
db.session.commit()
return jsonify(log_rule.serialized)
def process_pool():
form = request.form.to_dict()
for property in boolean_properties:
if property not in form:
form[property] = 'off'
return jsonify(factory(Pool, **form).serialized)
def edit_object():
cls, kwargs = process_kwargs(app, **request.form.to_dict())
obj = factory(cls, **kwargs)
return jsonify(obj.serialized)
