def insert_interface_unit(iface_node, unit, service_id_regex): """ Creates or updates logical interface units. """ user = utils.get_user() unit_name = u'{}'.format(unit['unit']) # Unit names are unique per interface result = iface_node.get_unit(unit_name) if result.get('Part_of', None): unit_node = result.get('Part_of')[0].get('node') else: node_handle = utils.create_node_handle(unit_name, 'Unit', 'Logical') unit_node = node_handle.get_node() helpers.set_part_of(user, iface_node, unit_node.handle_id) logger.info('Unit {interface}.{unit} created.'.format( interface=iface_node.data['name'], unit=unit_node.data['name'])) helpers.set_noclook_auto_manage(unit_node, True) unit['ip_addresses'] = [ address.lower() for address in unit.get('address', '') ] property_keys = ['description', 'ip_addresses', 'vlanid'] helpers.dict_update_node(user, unit_node.handle_id, unit, property_keys) # Auto depend service on unit auto_depend_services(unit_node.handle_id, unit.get('description', ''), service_id_regex, 'Unit')
def insert_ports(ports, pdu_node): user = utils.get_user() for port in ports: port_name = port.get('name') if port_name: port_node = get_or_create_port(port_name, pdu_node, user) helpers.set_noclook_auto_manage(port_node, True) property_keys = ['description', 'name'] helpers.dict_update_node(user, port_node.handle_id, port, property_keys)
def test_report_view(self): host_user = self.create_node('AwesomeCo', 'host-user', 'Relation') host = self.create_node('sweet-host.nordu.net', 'host', 'Logical') host_node = host.get_node() set_noclook_auto_manage(host_node, True) set_user(self.user, host.get_node(), host_user.handle_id) url = reverse('host_users_report') resp = self.client.get(url) self.assertContains(resp, host.node_name)
def get_peering_partner(peering): """ Inserts a new node of the type Peering partner and ensures that this node is unique for AS number. Returns the created node. """ try: return PEER_AS_CACHE[peering['as_number']] except KeyError: logger.info('Peering Partner {name} not in cache.'.format( name=peering.get('description'))) pass user = utils.get_user() peer_node = None peer_properties = {'name': 'Missing description', 'as_number': '0'} if peering.get('description'): peer_properties['name'] = peering.get('description') if peering.get('as_number'): peer_properties['as_number'] = peering.get('as_number') hits = nc.get_nodes_by_value(nc.graphdb.manager, prop='as_number', value=peer_properties['as_number']) found = 0 for node in hits: peer_node = nc.get_node_model(nc.graphdb.manager, node['handle_id']) helpers.set_noclook_auto_manage(peer_node, True) if peer_node.data[ 'name'] == 'Missing description' and peer_properties[ 'name'] != 'Missing description': helpers.dict_update_node(user, peer_node.handle_id, peer_properties) logger.info('Peering Partner {name} fetched.'.format( name=peer_properties['name'])) found += 1 if found > 1: logger.error( 'Found more then one Peering Partner with AS number {!s}'. format(peer_properties['as_number'])) if not peer_node: node_handle = utils.create_node_handle(peer_properties['name'], 'Peering Partner', 'Relation') peer_node = node_handle.get_node() helpers.set_noclook_auto_manage(peer_node, True) helpers.dict_update_node(user, peer_node.handle_id, peer_properties, peer_properties.keys()) logger.info('Peering Partner {name} created.'.format( name=peer_properties['name'])) PEER_AS_CACHE[peering['as_number']] = peer_node return peer_node
def insert_juniper_bgp_peerings(bgp_peerings): """ Inserts all BGP peerings for all routers collected by the juniper_conf producer. This is to be able to get all the peerings associated to the right interfaces. """ for peering in bgp_peerings: peering_group = peering.get('group', 'Unknown Peering Group') peering_group_handle = utils.get_unique_node_handle( peering_group, 'Peering Group', 'Logical', case_insensitive=False) peering_group_node = peering_group_handle.get_node() helpers.set_noclook_auto_manage(peering_group_node, True) peering_type = peering.get('type') if peering_type == 'internal': continue # Not implemented elif peering_type == 'external': insert_external_bgp_peering(peering, peering_group_node)
def insert_external_bgp_peering(peering, peering_group): """ Creates/updates the relationship and nodes needed to express the external peerings. """ user = utils.get_user() # Get or create the peering partner, unique per AS peer_node = get_peering_partner(peering) if peer_node is None: # We are done. This is a broken peering. return # Get all relationships with this ip address, should never be more than one remote_address = peering.get('remote_address', None).lower() if remote_address: # DEBUG try: result = peer_node.get_peering_group(peering_group.handle_id, remote_address) except AttributeError: print(peer_node) sys.exit(1) if not result.get('Uses'): result = peer_node.set_peering_group(peering_group.handle_id, remote_address) relationship_id = result.get('Uses')[0]['relationship_id'] relationship = nc.get_relationship_model(nc.graphdb.manager, relationship_id) helpers.set_noclook_auto_manage(relationship, True) if result.get('Uses')[0].get('created', False): activitylog.create_relationship(user, relationship) # Match the remote address against a local network dependency_node, local_address = match_remote_ip_address( ipaddress.ip_address(remote_address)) if dependency_node and local_address: result = peering_group.get_group_dependency( dependency_node.handle_id, local_address) if not result.get('Depends_on'): result = peering_group.set_group_dependency( dependency_node.handle_id, local_address) relationship_id = result.get('Depends_on')[0]['relationship_id'] relationship = nc.get_relationship_model(nc.graphdb.manager, relationship_id) helpers.set_noclook_auto_manage(relationship, True) if result.get('Depends_on')[0].get('created', False): activitylog.create_relationship(user, relationship) logger.info( 'Peering Partner {name} done.'.format(name=peer_node.data['name']))
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 insert_juniper_node(name, model, version, node_type='Router', hardware=None): """ Inserts a physical meta type node of the type Router. Returns the node created. """ logger.info('Processing {name}...'.format(name=name)) user = utils.get_user() node_handle = utils.get_unique_node_handle(name, node_type, 'Physical') node = node_handle.get_node() node_dict = {'name': name, 'model': model, 'version': version} if hardware: node_dict['serial_number'] = hardware.get('serial_number') helpers.dict_update_node(user, node.handle_id, node_dict, node_dict.keys()) helpers.set_noclook_auto_manage(node, True) return node
def get_peering_partner(peering): """ Inserts a new node of the type Peering partner and ensures that this node is unique for AS number. Returns the created node. """ try: return PEER_AS_CACHE[peering['as_number']] except KeyError: logger.info('Peering Partner {name} not in cache.'.format( name=peering.get('description'))) pass user = utils.get_user() peer_node = None peer_properties = {'name': 'Missing description', 'as_number': '0'} # neither description or as_number error and return if not (peering.get('description') or peering.get('as_number')): logger.error('Neither AS number nor description in peering %s', peering) return None if peering.get('description'): peer_properties['name'] = peering.get('description') if peering.get('as_number'): peer_properties['as_number'] = peering.get('as_number') # as number is most important hits = nc.get_nodes_by_value(nc.graphdb.manager, prop='as_number', value=peer_properties['as_number']) found = 0 for node in hits: peer_node = nc.get_node_model(nc.graphdb.manager, node['handle_id']) helpers.set_noclook_auto_manage(peer_node, True) if peer_node.data[ 'name'] == 'Missing description' and peer_properties[ 'name'] != 'Missing description': helpers.dict_update_node(user, peer_node.handle_id, peer_properties) logger.info('Peering Partner {name} fetched.'.format( name=peer_properties['name'])) found += 1 if found > 1: logger.error( 'Found more then one Peering Partner with AS number {!s}'. format(peer_properties['as_number'])) if not peer_node: # since we have a AS number we will create a new Peering Partner, even if name is missing or exists node_handle = utils.create_node_handle(peer_properties['name'], 'Peering Partner', 'Relation') peer_node = node_handle.get_node() helpers.set_noclook_auto_manage(peer_node, True) helpers.dict_update_node(user, peer_node.handle_id, peer_properties, peer_properties.keys()) logger.info('Peering Partner %s AS(%s) created.', peer_properties['name'], peer_properties['as_number']) # Handle peer with name only if not peer_node and peering.get('description'): # Try and get peer_partners res = NodeHandle.objects.filter( node_name__iexact=peer_properties['name'], node_type__type='Peering Partner').order_by('-modified') for ph in res: peer_node = ph.get_node() break if not peer_node: # create peer_nh = utils.get_unique_node_handle(peer_properties['name'], 'Peering Partner', 'Relation') peer_node = peer_nh.get_node() if not peer_node.data.get('as_number'): # Peering partner did not exist logger.warning( 'Peering Partner %s without AS number created for peering: %s', peer_node.data.get('name'), peering) # AS number is going to be 0, but that is ok helpers.dict_update_node(user, peer_node.handle_id, peer_properties, peer_properties.keys()) elif peer_node.data.get('as_number') != '0': # warn about as number not being in peering logger.warning( 'Peering found for Peering Partner %s without the AS number %s mentioned. Peering: %s', peer_properties['name'], peer_node.data.get('as_number'), peering) helpers.set_noclook_auto_manage(peer_node, True) PEER_AS_CACHE[peering['as_number']] = peer_node return peer_node