def remove_peer_conf(user, data_age):
peerq = """
MATCH (peer_group:Node:Peering_Group)
MATCH (peer_group)<-[r:Uses]-(peering_partner:Peering_Partner)
WHERE (peer_group.noclook_auto_manage = true) OR (r.noclook_auto_manage = true)
RETURN collect(distinct peer_group.handle_id) as peer_groups, collect(id(r)) as uses_relationships
"""
peer_result = nc.query_to_dict(nc.graphdb.manager, peerq)
for relationship_id in peer_result.get('uses_relationships', []):
relationship = nc.get_relationship_model(nc.graphdb.manager,
relationship_id)
if relationship:
last_seen, expired = helpers.neo4j_data_age(
relationship.data, data_age)
if expired:
rel_info = helpers.relationship_to_str(relationship)
helpers.delete_relationship(user, relationship.id)
logger.warning('Deleted relationship {rel_info}'.format(
rel_info=rel_info))
for handle_id in peer_result.get('peer_groups', []):
peer_group = nc.get_node_model(nc.graphdb.manager, handle_id)
if peer_group:
last_seen, expired = helpers.neo4j_data_age(
peer_group.data, data_age)
if expired:
helpers.delete_node(user, peer_group.handle_id)
logger.warning('Deleted node {name} ({handle_id}).'.format(
name=peer_group.data.get('name'), handle_id=handle_id))
def remove_router_conf(user, data_age):
routerq = """
MATCH (router:Node:Router)
OPTIONAL MATCH (router)-[:Has*1..]->(physical)<-[:Part_of]-(logical)
WHERE (physical.noclook_auto_manage = true) OR (logical.noclook_auto_manage = true)
RETURN collect(distinct physical.handle_id) as physical, collect(distinct logical.handle_id) as logical
"""
router_result = nc.query_to_dict(nc.graphdb.manager, routerq)
for handle_id in router_result.get('logical', []):
logical = nc.get_node_model(nc.graphdb.manager, handle_id)
if logical:
last_seen, expired = helpers.neo4j_data_age(logical.data, data_age)
if expired:
helpers.delete_node(user, logical.handle_id)
logger.warning('Deleted logical router: %s (%s).',
logical.data.get('name'), handle_id)
for handle_id in router_result.get('physical', []):
physical = nc.get_node_model(nc.graphdb.manager, handle_id)
if physical:
last_seen, expired = helpers.neo4j_data_age(
physical.data, data_age)
if expired:
helpers.delete_node(user, physical.handle_id)
logger.warning('Deleted physical router: %s (%s).',
physical.data.get('name'), handle_id)
def optical_node_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
optical_node = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(optical_node.data)
location_path = optical_node.get_location_path()
connections = optical_node.get_connections()
dependent = optical_node.get_dependent_as_types()
dependencies = optical_node.get_dependencies_as_types()
urls = helpers.get_node_urls(optical_node, location_path, dependent,
dependencies, connections)
return render(
request, 'noclook/detail/optical_node_detail.html', {
'node': optical_node,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'location_path': location_path,
'dependent': dependent,
'dependencies': dependencies,
'connections': connections,
'history': True,
'urls': urls
})
def firewall_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
firewall = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(firewall.data)
location_path = firewall.get_location_path()
# Get ports in firewall
connections = firewall.get_connections()
host_services = firewall.get_host_services()
dependent = firewall.get_dependent_as_types()
dependencies = firewall.get_dependencies_as_types()
relations = firewall.get_relations()
scan_enabled = helpers.app_enabled("apps.scan")
return render(
request, 'noclook/detail/firewall_detail.html', {
'node_handle': nh,
'node': firewall,
'last_seen': last_seen,
'expired': expired,
'host_services': host_services,
'connections': connections,
'dependent': dependent,
'dependencies': dependencies,
'relations': relations,
'location_path': location_path,
'history': True,
'scan_enabled': scan_enabled
})
def external_equipment_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
external_equipment = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(external_equipment.data)
# Get ports in equipment
connections = external_equipment.get_connections()
# Get location
location_path = external_equipment.get_location_path()
# Get owner
relations = external_equipment.get_relations()
# Get dependents
dependent = external_equipment.get_dependent_as_types()
print(dependent)
return render(
request, 'noclook/detail/external_equipment_detail.html', {
'node': external_equipment,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'connections': connections,
'relations': relations,
'dependent': dependent,
'location_path': location_path,
'history': True
})
def pdu_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
pdu = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(pdu.data)
location_path = pdu.get_location_path()
# Get ports in pdu
connections = pdu.get_connections()
host_services = pdu.get_host_services()
dependent = pdu.get_dependent_as_types()
dependencies = pdu.get_dependencies_as_types()
relations = pdu.get_relations()
urls = helpers.get_node_urls(pdu, host_services, connections, dependent,
dependencies, relations, location_path)
scan_enabled = helpers.app_enabled("apps.scan")
return render(
request, 'noclook/detail/pdu_detail.html', {
'node_handle': nh,
'node': pdu,
'last_seen': last_seen,
'expired': expired,
'host_services': host_services,
'connections': connections,
'dependent': dependent,
'dependencies': dependencies,
'relations': relations,
'location_path': location_path,
'history': True,
'urls': urls,
'scan_enabled': scan_enabled
})
def customer_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
customer = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(customer.data)
result = customer.with_same_name()
same_name_relations = NodeHandle.objects.in_bulk(
(result.get('ids'))).values()
# Handle relationships
uses_relationships = customer.get_uses()
owned_equipment = customer.get_owns()
urls = helpers.get_node_urls(customer, same_name_relations,
uses_relationships, owned_equipment)
return render(
request, 'noclook/detail/customer_detail.html', {
'node_handle': nh,
'node': customer,
'last_seen': last_seen,
'expired': expired,
'same_name_relations': same_name_relations,
'uses_relationships': uses_relationships,
'owned_equipment': owned_equipment,
'history': True,
'urls': urls,
})
def rack_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
rack = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(rack.data)
location_path = rack.get_location_path()
# Get equipment in rack
_located_in = rack.get_located_in().get('Located_in', [])
physical_relationships = {
"Located_in":
_nodes_without(_located_in, 'operational_state', ['decommissioned'])
}
urls = helpers.get_node_urls(rack, physical_relationships, location_path)
return render(
request, 'noclook/detail/rack_detail.html', {
'node': rack,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'physical_relationships': physical_relationships,
'location_path': location_path,
'history': True,
'urls': urls
})
def host_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
host = nc.get_node_model(nc.graphdb.manager, nh.handle_id)
last_seen, expired = helpers.neo4j_data_age(host.data)
location_path = host.get_location_path()
# Handle relationships
host_services = host.get_host_services()
relations = host.get_relations()
dependent = host.get_dependent_as_types()
# Get ports in Host
connections = host.get_connections()
if not any(dependent.values()):
dependent = None
dependencies = host.get_dependencies_as_types()
urls = helpers.get_node_urls(relations, host_services, dependent,
dependencies)
scan_enabled = helpers.app_enabled("apps.scan")
return render(
request, 'noclook/detail/host_detail.html', {
'node_handle': nh,
'node': host,
'last_seen': last_seen,
'expired': expired,
'relations': relations,
'host_services': host_services,
'dependent': dependent,
'dependencies': dependencies,
'location_path': location_path,
'history': True,
'urls': urls,
'connections': connections,
'scan_enabled': scan_enabled,
})
def peering_partner_detail(request, handle_id):
# TODO: Needs to be rewritten using cypher
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
peering_partner = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(peering_partner.data)
result = peering_partner.with_same_name()
same_name_relations = NodeHandle.objects.in_bulk(
(result.get('ids'))).values()
# TODO: A better model for Peerings would be:
# (unit)<-[:Depends_on]-(peering:Peering)<-[:Uses]-(partner:Peering_Partner)
# (peering:Peering)-[:Depends_on]->(group:Peering_Group)
user_dependencies = []
peering_groups = peering_partner.get_uses().get('Uses', [])
# pruning groups...
group_dependencies = {}
for group in peering_groups:
gnode = group['node']
gnode_id = gnode.handle_id
if not (gnode_id in group_dependencies):
group_dependencies[gnode_id] = gnode.get_dependencies().get(
'Depends_on', [])
for group in peering_groups:
user_address = ipaddress.ip_address(
group['relationship']['ip_address'])
peering_group = {
'peering_group': group['node'],
'user_address': u'{}'.format(user_address),
}
for unit in group_dependencies[group['node'].handle_id]:
network_address = ipaddress.ip_network(
unit['relationship']['ip_address'], strict=False)
if user_address in network_address:
peering_group.update({
# TODO: warn: unit.get.placement_path called from view
'unit':
unit['node'],
'network_address':
u'{}'.format(network_address),
'relationship':
unit['relationship']
})
break
user_dependencies.append(peering_group)
urls = helpers.get_node_urls(peering_partner, same_name_relations,
user_dependencies)
return render(
request, 'noclook/detail/peering_partner_detail.html', {
'node_handle': nh,
'node': peering_partner,
'last_seen': last_seen,
'expired': expired,
'same_name_relations': same_name_relations,
'user_dependencies': user_dependencies,
'history': True,
'urls': urls
})
def site_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
site = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(site.data)
relations = site.get_relations()
# Direct equipment (aka not racked)
equipment_relationships = _nodes_without(
site.get_located_in().get('Located_in', []), 'operational_state',
['decommissioned'])
# Racked equipment
q = """
MATCH (site:Site {handle_id: {handle_id}})-[:Has]->(rack:Rack)
OPTIONAL MATCH (rack)<-[:Located_in]-(item:Node)
WHERE NOT item.operational_state IN ['Decommissioned'] OR NOT exists(item.operational_state)
RETURN rack, item order by toLower(rack.name), toLower(item.name)
"""
rack_list = nc.query_to_list(nc.graphdb.manager, q, handle_id=nh.handle_id)
# Create racked equipment table
racks_table = Table('Rack', 'Equipment')
racks_table.rows = [
TableRow(r.get('rack'), r.get('item')) for r in rack_list
]
# rooms
q = """
MATCH (site:Site {handle_id: {handle_id}})-[:Has]->(room:Room)
RETURN room order by toLower(room.name)
"""
rooms_list = nc.query_to_list(nc.graphdb.manager,
q,
handle_id=nh.handle_id)
rooms_table = Table('Rooms')
rooms_table.rows = [TableRow(r.get('room')) for r in rooms_list]
urls = helpers.get_node_urls(site, equipment_relationships, relations,
rack_list, rooms_list)
return render(
request, 'noclook/detail/site_detail.html', {
'node_handle': nh,
'node': site,
'last_seen': last_seen,
'expired': expired,
'equipment_relationships': equipment_relationships,
'relations': relations,
'racks_table': racks_table,
'rooms_table': rooms_table,
'history': True,
'urls': urls,
})
def remove_router_conf(router_name, data_age, dry_run=False):
routerq = """
MATCH (router:Node:Router {{name: '{}'}})
OPTIONAL MATCH (router)-[:Has*1..]->(physical)
OPTIONAL MATCH (physical)<-[:Part_of]-(logical)
WHERE (physical.noclook_auto_manage = true) OR (logical.noclook_auto_manage = true)
RETURN collect(distinct physical.handle_id) as physical, collect(distinct logical.handle_id) as logical
""".format(router_name)
router_result = nc.query_to_dict(nc.graphdb.manager, routerq)
for handle_id in router_result.get('logical', []):
logical = nc.get_node_model(nc.graphdb.manager, handle_id)
if logical:
last_seen, expired = helpers.neo4j_data_age(logical.data, data_age)
if expired:
delete_node(logical, dry_run)
for handle_id in router_result.get('physical', []):
physical = nc.get_node_model(nc.graphdb.manager, handle_id)
if physical:
last_seen, expired = helpers.neo4j_data_age(physical.data, data_age)
if expired:
delete_node(physical, dry_run)
def switch_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
switch = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(switch.data)
location_path = switch.get_location_path()
# Get ports in switch
connections = switch.get_connections()
host_services = switch.get_host_services()
dependent = switch.get_dependent_as_types()
dependencies = switch.get_dependencies_as_types()
relations = switch.get_relations()
urls = helpers.get_node_urls(switch, host_services, connections, dependent,
dependencies, relations, location_path)
scan_enabled = helpers.app_enabled("apps.scan")
hw_name = "{}-hardware.json".format(switch.data.get('name', 'switch'))
hw_attachment = helpers.find_attachments(handle_id, hw_name).first()
if hw_attachment:
try:
hardware_modules = [
json.loads(helpers.attachment_content(hw_attachment))
]
except IOError as e:
logger.warning(
'Missing hardware modules json for router %s(%s). Error was: %s',
nh.node_name, nh.handle_id, e)
hardware_modules = []
else:
hardware_modules = []
return render(
request, 'noclook/detail/switch_detail.html', {
'node_handle': nh,
'node': switch,
'last_seen': last_seen,
'expired': expired,
'host_services': host_services,
'connections': connections,
'dependent': dependent,
'dependencies': dependencies,
'relations': relations,
'location_path': location_path,
'history': True,
'urls': urls,
'scan_enabled': scan_enabled,
'hardware_modules': hardware_modules
})
def peering_group_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
peering_group = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(peering_group.data)
# TODO: A better model for Peerings would be:
# (unit)<-[:Depends_on]-(peering:Peering)<-[:Uses]-(partner:Peering_Partner)
# (peering:Peering)-[:Depends_on]->(group:Peering_Group)
user_dependencies = []
dependencies = peering_group.get_dependencies()
users = peering_group.get_relations().get('Uses', [])
for item in dependencies.get('Depends_on', []):
network_address = ipaddress.ip_network(
item['relationship']['ip_address'], strict=False)
interface = {
'unit': item['node'],
# calls neo4j but there are almost no dependencies normally
'placement': item['node'].get_placement_path(),
'network_address': u'{}'.format(network_address),
'users': []
}
for user in users:
user_address = ipaddress.ip_address(
user['relationship']['ip_address'])
if user_address in network_address:
interface['users'].append({
'user':
user['node'],
'user_address':
u'{}'.format(user_address),
'relationship':
user['relationship']
})
user_dependencies.append(interface)
urls = helpers.get_node_urls(peering_group, user_dependencies)
return render(
request, 'noclook/detail/peering_group_detail.html', {
'node_handle': nh,
'node': peering_group,
'last_seen': last_seen,
'expired': expired,
'user_dependencies': user_dependencies,
'history': True,
'urls': urls
})
def host_service_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
host_service = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(host_service.data)
service_relationships = host_service.get_dependencies()
urls = helpers.get_node_urls(host_service, service_relationships)
return render(
request, 'noclook/detail/host_service_detail.html', {
'node_handle': nh,
'node': host_service,
'last_seen': last_seen,
'expired': expired,
'service_relationships': service_relationships,
'history': True,
'urls': urls
})
def optical_link_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
optical_link = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(optical_link.data)
relations = optical_link.get_relations()
dependent = optical_link.get_dependent_as_types()
dependencies = optical_link.get_dependencies_as_types()
return render(
request, 'noclook/detail/optical_link_detail.html', {
'node': optical_link,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'dependent': dependent,
'dependencies': dependencies,
'relations': relations,
'history': True
})
def end_user_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
end_user = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(end_user.data)
result = end_user.with_same_name()
same_name_relations = NodeHandle.objects.in_bulk(
(result.get('ids'))).values()
# Handle relationships
uses_relationships = end_user.get_uses()
return render(
request, 'noclook/detail/end_user_detail.html', {
'node_handle': nh,
'node': end_user,
'last_seen': last_seen,
'expired': expired,
'same_name_relations': same_name_relations,
'uses_relationships': uses_relationships,
'history': True
})
def cleanup_host_services(max_age, purge, dry_run):
max_age_hours = max_age * 24
max_last_seen = date.today() - timedelta(days=max_age)
host_service_type = NodeType.objects.get(type='Host Service')
host_services = NodeHandle.objects.filter(node_type=host_service_type)
for nh in host_services:
node = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(node.data, max_age_hours)
if purge:
if expired:
logger.warning('Deleting Host Service "%s"', nh.node_name)
if not dry_run:
nh.delete()
else:
# Cleanup old stuff
cleanup_host_service(nh, max_last_seen, dry_run)
else:
cleanup_host_service(nh, max_last_seen, dry_run)
def router_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
router = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(router.data)
location_path = router.get_location_path()
# Get all the Ports and what depends on the port.
connections = router.get_connections()
dependent = router.get_dependent_as_types()
hw_name = "{}-hardware.json".format(router.data.get('name', 'router'))
hw_attachment = helpers.find_attachments(handle_id, hw_name).first()
if hw_attachment:
try:
hardware_modules = [
json.loads(helpers.attachment_content(hw_attachment))
]
except IOError as e:
logger.warning(
'Missing hardware modules json for router %s(%s). Error was: %s',
nh.node_name, nh.handle_id, e)
hardware_modules = []
else:
hardware_modules = []
# TODO: generally very inefficient lookups in view...
urls = helpers.get_node_urls(router, location_path, dependent, connections,
hardware_modules)
return render(
request, 'noclook/detail/router_detail.html', {
'node_handle': nh,
'node': router,
'last_seen': last_seen,
'expired': expired,
'location_path': location_path,
'dependent': dependent,
'connections': connections,
'hardware_modules': hardware_modules,
'history': True,
'urls': urls
})
def optical_filter_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
ofilter = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(ofilter.data)
# Get ports in ODF
connections = ofilter.get_connections()
# Get location
location_path = ofilter.get_location_path()
urls = helpers.get_node_urls(ofilter, connections, location_path)
return render(
request, 'noclook/detail/optical_filter_detail.html', {
'node': ofilter,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'connections': connections,
'location_path': location_path,
'history': True,
'urls': urls
})
def cable_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
cable = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(cable.data)
# TODO: should be fixed in nc.get_connected_equipment
q = """
MATCH (n:Node {handle_id: {handle_id}})-[rel:Connected_to]->(port)
OPTIONAL MATCH (port)<-[:Has*1..10]-(end)
WITH rel, port, last(collect(end)) as end
OPTIONAL MATCH (end)-[:Located_in]->(location)
OPTIONAL MATCH (location)<-[:Has*1..10]-(site:Site)
RETURN id(rel) as rel_id, rel, port, end, location, site
ORDER BY end.name, port.name
"""
connections = nc.query_to_list(nc.graphdb.manager,
q,
handle_id=cable.handle_id)
# connections = cable.get_connected_equipment()
relations = cable.get_relations()
dependent = cable.get_dependent_as_types()
connection_path = cable.get_connection_path()
urls = helpers.get_node_urls(cable, connections, relations, dependent)
if not any(dependent.values()):
dependent = None
return render(
request, 'noclook/detail/cable_detail.html', {
'node': cable,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'connections': connections,
'dependent': dependent,
'connection_path': connection_path,
'history': True,
'relations': relations,
'urls': urls
})
def service_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
service = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(service.data)
relations = service.get_relations()
dependent = service.get_dependent_as_types()
dependencies = service.get_dependencies_as_types()
urls = helpers.get_node_urls(service, dependent, dependencies, relations)
return render(
request, 'noclook/detail/service_detail.html', {
'node': service,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'dependent': dependent,
'dependencies': dependencies,
'relations': relations,
'history': True,
'urls': urls
})
def unit_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
unit = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(unit.data)
location_path = unit.get_location_path()
dependent = unit.get_dependent_as_types()
dependencies = unit.get_dependencies_as_types()
urls = helpers.get_node_urls(unit, dependent, dependencies, location_path)
return render(
request, 'noclook/detail/unit_detail.html', {
'node': unit,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'dependent': dependent,
'dependencies': dependencies,
'location_path': location_path,
'history': True,
'urls': urls
})
def patch_panel_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
patch_panel = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(patch_panel.data)
# Get ports in Patch Panel
# connections = patch_panel.get_connections()
# TODO: should be fixed in nc.get_connections
q = """
MATCH (n:Node {handle_id: {handle_id}})-[:Has*1..10]->(porta:Port)
OPTIONAL MATCH (porta)<-[r0:Connected_to]-(cable)
OPTIONAL MATCH (cable)-[r1:Connected_to]->(portb:Port)
WHERE ID(r1) <> ID(r0)
OPTIONAL MATCH (portb)<-[:Has*1..10]-(end)
WITH porta, r0, cable, portb, r1, last(collect(end)) as end
OPTIONAL MATCH (end)-[:Located_in]->(location)
OPTIONAL MATCH (location)<-[:Has*1..10]-(site:Site)
RETURN porta, r0, cable, r1, portb, end, location, site
"""
connections = nc.query_to_list(nc.graphdb.manager,
q,
handle_id=patch_panel.handle_id)
# Get location
location_path = patch_panel.get_location_path()
urls = helpers.get_node_urls(patch_panel, connections, location_path)
return render(
request, 'noclook/detail/patch_panel_detail.html', {
'node': patch_panel,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'connections': connections,
'location_path': location_path,
'history': True,
'urls': urls
})
def host_provider_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
host_provider = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(host_provider.data)
result = host_provider.with_same_name()
same_name_relations = NodeHandle.objects.in_bulk(
(result.get('ids'))).values()
provides_relationships = host_provider.get_provides()
urls = helpers.get_node_urls(host_provider, same_name_relations,
provides_relationships)
return render(
request, 'noclook/detail/host_provider_detail.html', {
'node_handle': nh,
'node': host_provider,
'last_seen': last_seen,
'expired': expired,
'same_name_relations': same_name_relations,
'provides_relationships': provides_relationships,
'history': True,
'urls': urls
})
def site_owner_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
site_owner = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(site_owner.data)
result = site_owner.with_same_name()
same_name_relations = NodeHandle.objects.in_bulk(
(result.get('ids'))).values()
responsible_relations = site_owner.get_responsible_for()
urls = helpers.get_node_urls(site_owner, same_name_relations,
responsible_relations)
return render(
request, 'noclook/detail/site_owner_detail.html', {
'node_handle': nh,
'node': site_owner,
'last_seen': last_seen,
'expired': expired,
'same_name_relations': same_name_relations,
'responsible_relations': responsible_relations,
'history': True,
'urls': urls
})
def host_user_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
# Get node from neo4j-database
host_user = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(host_user.data)
result = host_user.with_same_name()
same_name_relations = NodeHandle.objects.in_bulk(
(result.get('ids'))).values()
q = """
MATCH (n:Node {handle_id: {handle_id}})-[r:Uses|:Owns]->(u)
RETURN
labels(u) as labels,
u.handle_id as handle_id,
u.name as name,
u.noclook_last_seen as noclook_last_seen,
u.noclook_auto_manage as noclook_auto_manage
"""
host_relationships = nc.query_to_list(nc.graphdb.manager,
q,
handle_id=host_user.handle_id)
urls = helpers.get_node_urls(host_user, same_name_relations,
host_relationships)
return render(
request,
'noclook/detail/host_user_detail.html',
{
'node_handle': nh,
'node': host_user,
'last_seen': last_seen,
'expired': expired,
'same_name_relations': same_name_relations,
'host_relationships': host_relationships,
'history': True,
'urls': urls
},
)
def cable_detail(request, handle_id):
nh = get_object_or_404(NodeHandle, pk=handle_id)
cable = nh.get_node()
last_seen, expired = helpers.neo4j_data_age(cable.data)
connections = cable.get_connected_equipment()
relations = cable.get_relations()
dependent = cable.get_dependent_as_types()
connection_path = cable.get_connection_path()
urls = helpers.get_node_urls(cable, connections, relations, dependent)
if not any(dependent.values()):
dependent = None
return render(
request, 'noclook/detail/cable_detail.html', {
'node': cable,
'node_handle': nh,
'last_seen': last_seen,
'expired': expired,
'connections': connections,
'dependent': dependent,
'connection_path': connection_path,
'history': True,
'relations': relations,
'urls': urls
})
def noclook_has_expired(item):
"""
Returns True if the item has a noclook_last_seen property and it has expired.
"""
last_seen, expired = neo4j_data_age(item)
return expired
def is_expired(node):
last_seen, expired = neo4j_data_age(node)
return expired
