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