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)
