def cleanup_hardware_v1(router_node, user): p = r"^\d+/\d+/\d+$" bad_interfaces = re.compile(p) # Cleanup ni hardware info v1... # Get all ports that are not directly on router q = """ MATCH (n:Router {handle_id: {handle_id}})-[:Has*1..3]->(:Node)-[r:Has]->(port:Port) RETURN port.handle_id as handle_id, port.name as name, id(r) as rel_id """ ports = nc.query_to_list(nc.graphdb.manager, q, handle_id=router_node.handle_id) for port in ports: if bad_interfaces.match(port['name']): # delete it! helpers.delete_node(user, port['handle_id']) else: # move it to router helpers.set_has(user, router_node, port['handle_id']) # Remove from hardware info (pic) helpers.delete_relationship(user, port['rel_id']) # Scrub interface properties..? # Remove hardware info q = """ MATCH (n:Router {handle_id: {handle_id}})-[:Has*]->(hw:Node) WHERE NOT hw:Port return hw.handle_id as handle_id, hw.name as name """ old_hardware = nc.query_to_list(nc.graphdb.manager, q, handle_id=router_node.handle_id) for hw in old_hardware: helpers.delete_node(user, hw['handle_id'])
def edit_rack(request, handle_id): # Get needed data from node nh, rack = helpers.get_nh_node(handle_id) parent = rack.get_parent() located_in = rack.get_located_in() located_in_categories = ['host', 'odf', 'optical-node', 'router'] if request.POST: form = forms.EditRackForm(request.POST) if form.is_valid(): # Generic node update helpers.form_update_node(request.user, rack.handle_id, form) # Rack specific updates if form.cleaned_data['relationship_parent']: parent_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_parent']) helpers.set_has(request.user, parent_nh.get_node(), rack.handle_id) if form.cleaned_data['relationship_located_in']: equipment = NodeHandle.objects.get(pk=form.cleaned_data['relationship_located_in']) helpers.set_location(request.user, equipment.get_node(), rack.handle_id) if 'saveanddone' in request.POST: return redirect(nh.get_absolute_url()) else: return redirect('%sedit' % nh.get_absolute_url()) else: form = forms.EditRackForm(rack.data) return render(request, 'noclook/edit/edit_rack.html', {'node_handle': nh, 'form': form, 'parent': parent, 'node': rack, 'located_in': located_in, 'parent_categories': 'site', 'located_in_categories': located_in_categories})
def create_node(self, item, parent_nh, user): errors = [] slug = slugify(item['node_type']).replace("_", "-") meta_type = META_TYPES.get(item['node_type'], 'Physical') nh = None if item['node_type'] in GENERIC_TYPES: nh = helpers.get_generic_node_handle(user, item['name'], slug, meta_type) else: try: nh = helpers.create_unique_node_handle(user, item['name'], slug, meta_type) except UniqueNodeError: # Should have been validated, but hey race conditions errors.append( u"Could not create a {} named '{}', since one already exist" .format(item['node_type'], item['name'])) if nh: helpers.dict_update_node( user, nh.handle_id, item, filtered_keys=['node_type', 'children', 'ports']) if item['node_type'] in HAS_RELATION: helpers.set_has(user, parent_nh.get_node(), nh.handle_id) else: helpers.set_location(user, nh.get_node(), parent_nh.handle_id) for child in item.get('children', []): cerrors = self.create_node(child, nh, user) errors += cerrors return errors
def edit_port(request, handle_id): nh, port = helpers.get_nh_node(handle_id) parent = port.get_parent() connected_to = port.get_connected_to() parent_categories = ['external-equipment', 'firewall', 'host', 'odf', 'optical-node', 'router', 'switch'] connections_categories = Dropdown.get('cable_types').as_values(False) if request.POST: form = forms.EditPortForm(request.POST) if form.is_valid(): # Generic node update helpers.form_update_node(request.user, port.handle_id, form) # Port specific updates if form.cleaned_data['relationship_parent']: parent_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_parent']) helpers.set_has(request.user, parent_nh.get_node(), port.handle_id) if form.cleaned_data['relationship_connected_to']: cable_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_connected_to']) helpers.set_connected_to(request.user, cable_nh.get_node(), port.handle_id) if 'saveanddone' in request.POST: return redirect(nh.get_absolute_url()) else: return redirect('%sedit' % nh.get_absolute_url()) else: form = forms.EditPortForm(port.data) return render(request, 'noclook/edit/edit_port.html', {'node_handle': nh, 'form': form, 'node': port, 'parent': parent, 'connected_to': connected_to, 'parent_categories': parent_categories, 'connections_categories': connections_categories})
def new_port(request, **kwargs): if request.POST: form = forms.NewPortForm(request.POST) if form.is_valid(): nh = helpers.form_to_generic_node_handle(request, form, 'port', 'Physical') helpers.form_update_node(request.user, nh.handle_id, form) if kwargs.get('parent_id', None) or form.cleaned_data['relationship_parent']: parent_id = kwargs.get('parent_id', None) if not parent_id: parent_id = form.cleaned_data['relationship_parent'] try: parent_nh = NodeHandle.objects.get(pk=parent_id) helpers.set_has(request.user, parent_nh.get_node(), nh.handle_id) except NoRelationshipPossible: nh.delete() form = forms.NewPortForm(request.POST) form.add_error('parent', 'Parent type can not have ports.') return render(request, 'noclook/create/create_port.html', {'form': form}) return redirect(nh.get_absolute_url()) else: form = forms.NewPortForm() return render(request, 'noclook/create/create_port.html', {'form': form})
def setUp(self): super(SearchTypeaheadPortsCase, self).setUp() self.typeahead_url = "/search/typeahead/ports" site = helpers.create_unique_node_handle(self.user, "UK-HEX", "site", "Location") rack = helpers.get_generic_node_handle(self.user, "A.01", "rack", "Location") helpers.set_has(self.user, site.get_node(), rack.handle_id) odf1 = helpers.create_unique_node_handle(self.user, "test-odf1", "odf", "Physical") odf1_node = odf1.get_node() helpers.set_location(self.user, odf1_node, rack.handle_id) helpers.create_port(odf1_node, "1+2", self.user) helpers.create_port(odf1_node, "3+4", self.user) odf2 = helpers.create_unique_node_handle(self.user, "other-odf2", "odf", "Physical") odf2_node = odf2.get_node() helpers.set_location(self.user, odf2_node, site.handle_id) helpers.create_port(odf2_node, "11+12", self.user) helpers.create_port(odf2_node, "13+14", self.user) router = helpers.create_unique_node_handle(self.user, "uk-hex.nordu.net", "router", "Physical") router_node = router.get_node() helpers.set_location(self.user, router_node, site.handle_id) helpers.create_port(router_node, "ge-0/0/1", self.user) helpers.create_port(router_node, "ge-0/0/2", self.user) helpers.create_port(router_node, "ge-0/1/1", self.user)
def get_or_create_port(port_name, node, user): result = node.get_port(port_name) if 'Has' in result: port_node = result.get('Has')[0].get('node') else: port_handle = utils.create_node_handle(port_name, 'Port', 'Physical') port_node = port_handle.get_node() helpers.set_has(user, node, port_node.handle_id) return port_node
def new_rack(request, **kwargs): if request.POST: form = forms.NewRackForm(request.POST) if form.is_valid(): nh = helpers.form_to_generic_node_handle(request, form, 'rack', 'Location') helpers.form_update_node(request.user, nh.handle_id, form) if form.cleaned_data['relationship_location']: parent_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_location']) helpers.set_has(request.user, parent_nh.get_node(), nh.handle_id) return redirect(nh.get_absolute_url()) else: form = forms.NewRackForm() return render(request, 'noclook/create/create_rack.html', {'form': form})
def test_decommissioned_equipment(self): self.skipTest('Not working as expected yet.') # Setup test data site = helpers.create_unique_node_handle(self.user, "Test site", "site", "Location") site_node = site.get_node() rack = helpers.get_generic_node_handle(self.user, "A.01", "rack", "Location") helpers.set_has(self.user, site_node, rack.handle_id) odf = helpers.create_unique_node_handle(self.user, "NI-TEST-ODF-01", "odf", "Physical") odf_node = odf.get_node() helpers.dict_update_node(self.user, odf.handle_id, {"max_ports": 24}) helpers.set_location(self.user, odf_node, rack.handle_id) decom_on = helpers.create_unique_node_handle(self.user, "NI-TEST-ON-01", "optical-node", "Physical") decom_on_node = decom_on.get_node() helpers.dict_update_node(self.user, decom_on.handle_id, {"operational_state": "Decommissioned"}) helpers.set_location(self.user, decom_on_node, rack.handle_id) helpers.create_port(decom_on_node, "1", self.user) helpers.create_port(decom_on_node, "2", self.user) # End test data resp = self.client.get(self.get_full_url(site) + "export") self.assertEquals('application/json', resp['Content-Type']) result = resp.json() # verify data self.assertEquals(1, len(result)) rack_result = result[0] self.assertDictContainsSubset({ 'name': 'A.01', 'node_type': 'Rack' }, rack_result) rack_equip = rack_result['children'] # Decommissioned equipment should be gone self.assertEquals(1, len(rack_equip)) self.assertDictContainsSubset( { 'node_type': 'ODF', 'name': 'NI-TEST-ODF-01' }, rack_equip[0]) self.assertEquals(2, len(rack_equip[0]['children']))
def insert_juniper_interfaces(router_node, interfaces): """ Insert all interfaces in the interfaces list with a Has relationship from the router_node. Some filtering is done for interface names that are not interesting. """ p = r""" .*\*|\.|all|tap|fxp.*|pfe.*|pfh.*|mt.*|pd.*|pe.*|vt.*|bcm.*|dsc.*|em.*|gre.*|ipip.*|lsi.*|mtun.*|pimd.*|pime.*| pp.*|pip.*|irb.*|demux.*|cbp.*|me.*|lo.* """ not_interesting_interfaces = re.compile(p, re.VERBOSE) user = utils.get_user() cleanup_hardware_v1(router_node, user) service_id_regex = _service_id_regex() for interface in interfaces: port_name = interface['name'] if port_name and not not_interesting_interfaces.match( port_name) and not interface.get('inactive', False): result = router_node.get_port(port_name) if 'Has' in result: port_node = result.get('Has')[0].get('node') else: node_handle = utils.create_node_handle(port_name, 'Port', 'Physical') port_node = node_handle.get_node() helpers.set_has(user, router_node, port_node.handle_id) helpers.set_noclook_auto_manage(port_node, True) property_keys = ['description', 'name'] helpers.dict_update_node(user, port_node.handle_id, interface, property_keys) # Update interface units for unit in interface['units']: if not unit.get('inactive', False): insert_interface_unit(port_node, unit, service_id_regex) # Auto depend services auto_depend_services(port_node.handle_id, interface.get('description', ''), service_id_regex) logger.info('{router} {interface} done.'.format( router=router_node.data['name'], interface=port_name)) else: logger.info('Interface {name} ignored.'.format(name=port_name))
def add_parent(self, user, location_nh, parent_nh): helpers.set_has(user, parent_nh.get_node(), location_nh.handle_id)
def add_has(self, user, physical_nh, physical_has_nh): helpers.set_has(user, physical_nh.get_node(), physical_has_nh.handle_id)
def link_has(cls, user, location_nh, has_nh): location_node = location_nh.get_node() has_id = has_nh.handle_id helpers.set_has(user, location_node, has_id)
def link_parent(cls, user, location_nh, parent_nh): parent_node = parent_nh.get_node() location_handle_id = location_nh.handle_id helpers.set_has(user, parent_node, location_handle_id)
def link_has(cls, user, physical_nh, physical2_nh): physical_node = physical_nh.get_node() physical2_handle_id = physical2_nh.handle_id helpers.set_has(user, physical_node, physical2_handle_id)
def test_populated_site(self): # Setup test data site = helpers.create_unique_node_handle(self.user, "Test site", "site", "Location") site_node = site.get_node() rack = helpers.get_generic_node_handle(self.user, "A.01", "rack", "Location") helpers.set_has(self.user, site_node, rack.handle_id) odf = helpers.create_unique_node_handle(self.user, "NI-TEST-ODF-01", "odf", "Physical") odf_node = odf.get_node() helpers.dict_update_node(self.user, odf.handle_id, {"max_ports": 24}) helpers.set_location(self.user, odf_node, rack.handle_id) helpers.create_port(odf_node, "1", self.user) helpers.create_port(odf_node, "2", self.user) helpers.create_port(odf_node, "3", self.user) router = helpers.create_unique_node_handle( self.user, "ni-test.routers.nordu.net", "router", "Physical") router_node = router.get_node() helpers.dict_update_node(self.user, router.handle_id, { "operational_state": "Testing", "rack_units": 2 }) helpers.set_location(self.user, router_node, rack.handle_id) odf2 = helpers.get_generic_node_handle(self.user, "NI-TEST-ODF-02", "odf", "Physical") odf2_node = odf2.get_node() helpers.set_location(self.user, odf2_node, site.handle_id) # Done setting up testdata resp = self.client.get(self.get_full_url(site) + "export") self.assertEquals('application/json', resp['Content-Type']) result = resp.json() # verify data self.assertEquals(2, len(result)) self.assertDictContainsSubset({ 'name': 'A.01', 'node_type': 'Rack' }, result[0]) self.assertDictContainsSubset( { 'node_type': 'ODF', 'name': 'NI-TEST-ODF-02' }, result[1]) # Check racked equipment rack_equp = result[0]['children'] self.assertEquals(2, len(rack_equp)) odf1_result = rack_equp[0] self.assertDictContainsSubset( { 'node_type': 'ODF', 'name': 'NI-TEST-ODF-01', 'max_ports': 24 }, odf1_result) # Check ODF ports odf1_ports = odf1_result['children'] self.assertEquals(3, len(odf1_ports)) self.assertDictContainsSubset( { 'node_type': 'Port', 'name': '1', 'port_type': '' }, odf1_ports[0]) self.assertDictContainsSubset( { 'node_type': 'Port', 'name': '2', 'description': '' }, odf1_ports[1]) self.assertDictContainsSubset({ 'node_type': 'Port', 'name': '3' }, odf1_ports[2]) # Check router router = rack_equp[1] self.assertDictContainsSubset( { 'node_type': 'Router', 'name': 'ni-test.routers.nordu.net' }, router)
def setUp(self): super(CableResourceTest, self).setUp() # Set up a user self.username = '******' self.password = '******' self.user = User.objects.create(username=self.username, password=self.password) self.api_key = ApiKey.objects.create(user=self.user, key='testkey') # Set up an ID generator self.id_generator = UniqueIdGenerator.objects.create( name='nordunet_cable_id', base_id_length=6, zfill=True, prefix='NU-0', creator=self.user) # Set up initial data self.router_node_type = NodeType.objects.create(type='Router', slug="router") self.port_node_type = NodeType.objects.create(type='Port', slug="port") self.cable_node_type = NodeType.objects.create(type='Cable', slug="cable") self.optical_node_node_type = NodeType.objects.create( type='Optical Node', slug="optical-node") # Have to create a service type as services can't be created without it. self.service_node_type = NodeType.objects.create(type='Service', slug="service") self.router1 = NodeHandle.objects.create( node_name='Test Router 1', node_type=self.router_node_type, node_meta_type='Physical', creator=self.user, modifier=self.user, ) self.router2 = NodeHandle.objects.create( node_name='Test Router 2', node_type=self.router_node_type, node_meta_type='Physical', creator=self.user, modifier=self.user, ) self.port1 = NodeHandle.objects.create( node_name='Test Port 1', node_type=self.port_node_type, node_meta_type='Physical', creator=self.user, modifier=self.user, ) self.port2 = NodeHandle.objects.create( node_name='Test Port 2', node_type=self.port_node_type, node_meta_type='Physical', creator=self.user, modifier=self.user, ) helpers.set_has(self.user, self.router1.get_node(), self.port1.handle_id) helpers.set_has(self.user, self.router2.get_node(), self.port2.handle_id)
def setUp(self): super(ServiceL2VPNResourceTest, self).setUp() # Set up a user self.username = '******' self.password = '******' self.user = User.objects.create(username=self.username, password=self.password) self.api_key = ApiKey.objects.create(user=self.user, key='testkey') # Set up an ID generator self.id_generator = UniqueIdGenerator.objects.create( name='nordunet_service_id', base_id_length=6, zfill=True, prefix='NU-S', creator=self.user) # Load the default forms global_preferences['general__data_domain'] = 'nordunet' global_preferences['id_generators__services'] = 'nordunet_service_id' reload(forms) # Set up initial data router_node_type = NodeType.objects.create(type='Router', slug="router") port_node_type = NodeType.objects.create(type='Port', slug="port") unit_node_type = NodeType.objects.create(type='Unit', slug="unit") testing_service_class, created = ServiceClass.objects.get_or_create( name='Testing') l2vpn_service_type, created = ServiceType.objects.get_or_create( name='L2VPN', service_class=testing_service_class) if_switch_service_type, created = ServiceType.objects.get_or_create( name='Interface Switch', service_class=testing_service_class) # Have to create a service type as services can't be created without it. service_node_type = NodeType.objects.create(type='Service', slug="service") self.router1 = NodeHandle.objects.create( node_name='Test Router 1', node_type=router_node_type, node_meta_type='Physical', creator=self.user, modifier=self.user, ) self.router2 = NodeHandle.objects.create( node_name='Test Router 2', node_type=router_node_type, node_meta_type='Physical', creator=self.user, modifier=self.user, ) self.port1 = NodeHandle.objects.create( node_name='Test Port 1', node_type=port_node_type, node_meta_type='Physical', creator=self.user, modifier=self.user, ) self.port2 = NodeHandle.objects.create( node_name='Test Port 2', node_type=port_node_type, node_meta_type='Physical', creator=self.user, modifier=self.user, ) self.unit1 = NodeHandle.objects.create( node_name='Test Unit 1', node_type=unit_node_type, node_meta_type='Logical', creator=self.user, modifier=self.user, ) self.unit2 = NodeHandle.objects.create( node_name='Test Unit 2', node_type=unit_node_type, node_meta_type='Logical', creator=self.user, modifier=self.user, ) self.DEFAULT_HANDLE_IDS = [ self.router1.handle_id, self.router2.handle_id, self.port1.handle_id, self.port2.handle_id, self.unit1.handle_id, self.unit2.handle_id ] helpers.set_has(self.user, self.router1.get_node(), self.port1.handle_id) helpers.set_has(self.user, self.router2.get_node(), self.port2.handle_id) helpers.set_part_of(self.user, self.port1.get_node(), self.unit1.handle_id) helpers.set_part_of(self.user, self.port2.get_node(), self.unit2.handle_id)