def create_node_relationship(node_a, node_b, leg, graph_object):
a = Node("Airport",
lat=node_a["latitude"],
lon=node_a["longitude"],
name=node_a["name"],
location=node_a["location"],
state=node_a["state"],
country=node_a["country"],
start_date=node_a["start-date"],
code=node_a["code"])
a.__primarylabel__ = "name"
a.__primarykey__ = "name"
b = Node("Airport",
lat=node_b["latitude"],
lon=node_b["longitude"],
name=node_b["name"],
location=node_b["location"],
state=node_b["state"],
country=node_b["country"],
start_date=node_b["start-date"],
code=node_b["code"])
b.__primarylabel__ = "name"
b.__primarykey__ = "name"
connection = Relationship.type("CONNECTION")
graph_object.merge(connection(a, b, airline=leg))
def new_arp_neighbor_rel(self, Router):
arp_neighbor = self.snmp2json[self.NetElement][u'L3Domain'][u'ARP_Neighbors']
for i in arp_neighbor:
int_id = i
if ('Int_Id:' + int_id) in self.interfaces:
int_bw = self.interfaces['Int_Id:' + int_id]['ifSpeed']
int_name = self.interfaces['Int_Id:' + int_id]['ifDescr']
for j in arp_neighbor[i]:
if not '127.0.0.' in j:
ip_addr = j[0]
mac_addr = j[1]
neigh_info = j[2]
ip = Node('Ip_address', status = 'Active', address = ip_addr)
ip.__primarylabel__ = "Ip_address"
ip.__primarykey__ = "address"
if not self.find_ip_addr(ip_addr):
graph.create(ip)
query = ''' MATCH (i:Interface)-[:BELONGS_TO]->(r:Router), (ip:Ip_address)
WHERE (r.hostname = {hostname} and i.int_id = {int_id}) and ip.address = {ip_addr}
CREATE UNIQUE (i)-[:SEEN_BY_ARP]->(ip) '''
rel_arp_int_ip = graph.run(query, hostname = self.hostname,
int_id = int_id, ip_addr = ip_addr)
if (('0:50:56' or '0:c:29' or '0:25:b3') in mac_addr):
server = Node('Server', MAC = mac_addr, property = 'VmWare_VM')
server.__primarylabel__ = "Server"
server.__primarykey__ = "MAC"
CONFIGURED_IN = Relationship.type('CONFIGURED_IN')
rel_ip_server = graph.merge(CONFIGURED_IN(ip,server))
elif ('0:9:f:' in mac_addr):
firewall = Node('Firewall', MAC = mac_addr, property = 'FortiNet')
firewall.__primarylabel__ = 'Firewall'
firewall.__primarykey__ = 'MAC'
CONFIGURED_IN = Relationship.type('CONFIGURED_IN')
rel_ip_server = graph.merge(CONFIGURED_IN(ip,firewall))
self.arp_relationship(Router, firewall, int_name, int_bw)
elif (('5c:f3:fc' or '0:15:17') in mac_addr):
if re.search('5c:f3:fc', mac_addr):
server = Node('Server', MAC = mac_addr, property = 'IBM_SERVER')
else:
server = Node('Server', MAC = mac_addr, property = 'INTEL_SERVER')
server.__primarylabel__ = "Server"
server.__primarykey__ = "MAC"
CONFIGURED_IN = Relationship.type('CONFIGURED_IN')
rel_ip_server = graph.merge(CONFIGURED_IN(ip,server))
elif 'message' not in neigh_info:
hostname = neigh_info[u'hostname']
dev_info = neigh_info[u'description']
print (hostname, self.hostname, self.NetElement)
arp_router = Node('Router', hostname = hostname, devinfo = dev_info)
arp_router.__primarylabel__ = "Router"
arp_router.__primarykey__ = "hostname"
self.arp_relationship(Router, arp_router, int_name, int_bw, hostname)
def create_data_type_node(type: str, type_val: str) -> Node:
print('get_or_create_data_type_node : ', type, type_val)
n = None
if DataTypeEnum(type) is DataTypeEnum.ANALYTICS:
n = Node("Analytics", name=type_val)
n.__primarylabel__ = "Analytics"
n.__primarykey__ = "name"
elif DataTypeEnum(type) is DataTypeEnum.MODEL:
n = Node("Model", name=type_val)
n.__primarylabel__ = "Model"
n.__primarykey__ = "name"
return n
def organizations(graph):
#Transaction Container - where we store operations before committing to graph
register = graph.begin()
#Open file and assign to reader
fileIn = "organization.csv"
in_file = open(fileIn, 'r')
reader = csv.reader(in_file, delimiter=',')
try:
i = 0
j = 0
next(reader)
for row in reader:
if row:
user = strip(row[0])
organization = strip(row[1])
orgType = strip(row[2])
userNode = Node("User", user_id=user)
#primary key and label used for merge comparison
userNode.__primarylabel__ = "User"
userNode.__primarykey__ = "user_id"
organizationNode = Node("Organization",
name=organization,
type=orgType)
organizationNode.__primarylabel__ = "Organization"
organizationNode.__primarykey__ = "name"
WORKS_FOR = Relationship.type("WORKS_FOR")
#Merge combines if already exists, else creates new
register.merge(WORKS_FOR(userNode, organizationNode))
i += 1
j += 1
if (i == 4): #submits a batch every 4 lines read
register.commit()
print(j, "organization lines processed")
i = 0
register = graph.begin()
else:
register.commit() #submits remainder of lines read
print(j, "organization lines processed")
except Exception as e:
print(e, row, reader.line_num)
def graph_member(self, member):
"""Create a graph node for a member in GCP."""
logging.info("Graphing member " + member.name)
node = Node("member", type=member.type, name=member.name)
node.__primarylabel__ = "member"
node.__primarykey__ = "name"
for binding in member.sa_scopes:
# 1. Parse bindings for the service account user permissions
for key in binding.keys():
matcher = NodeMatcher(self.graph)
location_node = matcher.match(key, name=binding[key]).first()
# 2. Find the Org, project, or resource node at the binding level
if location_node is None:
logging.warning("No node found for {0} : {1}".format(
key, binding[key]))
logging.warning("{0} not mapped".format(member.name))
if location_node:
# 3. Create relationship with the resource node(s) and the member node
relationship = Relationship.type("iam_binding")
try:
self.graph.merge(relationship(node, location_node))
except ConnectionRefusedError as e:
logging.error(str(e))
logging.error(
"Unable to connect to the graph service, exiting.")
sys.exit()
def create_data_node(data_node: DataNode):
print('GraphService: create_data_node: data_node = ', data_node.type)
n_data = Node('Data',
url_prefix=data_node.url_prefix,
endpoint=data_node.endpoint,
description=data_node.description,
header=data_node.header)
n_data.__primarylabel__ = "Data"
n_data.__primarykey__ = "endpoint"
tx = graph.begin()
tx.merge(n_data)
if data_node.source is not None:
n_source = GraphService.create_source_node(data_node.source)
r_data_source = Relationship(n_data,
'SOURCE',
n_source,
name=data_node.source)
tx.merge(r_data_source)
if data_node.type is not None:
n_type = GraphService.create_data_type_node(
data_node.type, data_node.type_val)
r_data_type = Relationship(n_data, 'DATA_TYPE', n_type)
tx.merge(r_data_type)
tx.commit()
def update_event(events, key):
event = NodeObject("Event")
event.name = key
event.full_name = events.get("full_name")
print(event.full_name)
event.image = events.get("image")
event.object_id = events.get("object_id")
event.weight = events.get("weight")
type1 = events.get("type")
event.location = events.get("location")
event.keywords = events.get("keywords")
# print(event.keywords)
graph = neo4j_connect()
graph.nodes.match("Event")
graph.merge(event)
graph.push(event)
graph.run(
"MATCH(n:Event)-[r]->(p:Event_Category) detach delete r, p return p")
if type1 not in ('', None):
transaction = graph.begin()
event_type = Node("event_category", name=type1)
event_type.__primarylabel__ = "Event_Category"
event_type.__primarykey__ = type1
transaction.create(event_type)
rels_event = Relationship(event.__node__, "BELONG TYPE OF EVENT",
event_type)
transaction.create(rels_event)
transaction.commit()
transaction.finished()
return event.__node__
def importMondeDiploFiles(path_to_medias_francais,
path_to_relations_medias_francais):
''' import or mondediplo files in Neo4j database as "Entity" nodes and "ONED_BY"
relationships. Create all properties as Diplo_propname.
No relationship cretaed to other nodes
'''
medias_df = pd.read_csv(path_to_medias_francais, sep=' ')
# nodes
i = 0
totnbnodes = len(medias_df) - 1
print(totnbnodes, "nodes found in file")
for index, row in medias_df.iterrows():
i = 1 + 1
nodematch = graph.nodes.match(entity_name=row["nom"]).first()
if nodematch == None:
try:
nodematch = Node('Entity', entity_name=row["nom"])
nodematch.__primarylabel__ = 'Entity'
nodematch.__primarykey__ = 'entity_name'
graph.merge(nodematch)
except:
print("could not import ", row["nom"])
nodematch = None
if nodematch != None:
for key in row.keys():
nodematch["Diplo_" + key] = row[key]
graph.push(nodematch)
if i % 100 == 0:
print(".", end=" ")
if i % 1000 == 0:
print(i, "/", totnbnodes)
print(len(graph.nodes.match("Entity")), "Entities in db after import")
# links
relations_df = pd.read_csv(path_to_relations_medias_francais, sep=' ')
totnblinks = len(relations_df) - 1
print(totnblinks, "links found in file")
j = 0
for index, row in relations_df.iterrows():
j = j + 1
results = db.run(
"MATCH (n1:Entity) WHERE n1.Diplo_nom = $origine "
"MATCH (n2:Entity) WHERE n2.Diplo_nom = $cible "
"MERGE (n2)-[:OWNED_BY {valeur:$v, source:$s, datePubli:$dp, dateConsult:$dc}] ->(n1) ",
{
"origine": row['origine'],
"cible": row['cible'],
"v": row['valeur'],
"s": row['source'],
"dp": row['datePublication'],
"dc": row['dateConsultation']
})
if j % 100 == 0:
print(".", end=" ")
if j % 1000 == 0:
print(j, "/", totnblinks)
relfin = len(graph.relationships.match((), "OWNED_BY"))
print(
relfin,
" OWNED_BY relationships in db after import (or not : there's a bug)")
def test_can_merge_node_with_primary_label_and_key(graph):
graph.delete_all()
a = Node("Person", name="Alice")
a.__primarylabel__ = "Person"
a.__primarykey__ = "name"
graph.merge(a)
assert graph.nodes.match("Person", name="Alice").first() == a
def new_interfaces_node(self, router):
self.interfaces = self.snmp2json[self.NetElement][u'Interfaces']
for i in self.interfaces:
int_id = i.replace('Int_Id:', '')
for j in self.interfaces[i]:
if j == 'ifPhysAddress':
if_mac_address = self.interfaces[i][j]
if_uniqueness = if_mac_address + '_' + self.hostname + '_' + int_id
elif j == 'ifDescr':
if_name = self.interfaces[i][j]
elif j == 'ifOperStatus':
if_op_status = self.interfaces[i][j]
elif j == 'ifAdminStatus':
if_adm_status = self.interfaces[i][j]
elif j == 'ifSpeed':
if_speed = self.interfaces[i][j]
elif j == 'ifMtu':
if_mtu = self.interfaces[i][j]
interface = Node('Interface', name = if_name, int_id = int_id, MAC = if_mac_address, UNIQUENESS= if_uniqueness,
AdmStatus = if_adm_status, OpStatus = if_op_status, Speed = if_speed, MTU = if_mtu)
interface.__primarylabel__ = "Interface"
interface.__primarykey__ = "UNIQUENESS"
BELONGS_TO = Relationship.type('BELONGS_TO')
rel_router_int = graph.merge(BELONGS_TO(interface,router))
self.new_ip_addr_node()
def interests(graph):
#Transaction Container - where we store operations before committing to graph
register = graph.begin()
#Open file and assign to reader
fileIn = "interest.csv"
in_file = open(fileIn, 'r')
reader = csv.reader(in_file, delimiter=',')
try:
i = 0
j = 0
next(reader)
for row in reader:
if row:
user = strip(row[0])
interest = strip(row[1])
interestLevel = strip(row[2])
userNode = Node("User", user_id=user)
#primary key and label used for merge comparison
userNode.__primarylabel__ = "User"
userNode.__primarykey__ = "user_id"
interestNode = Node("Interest", name=interest)
interestNode.__primarylabel__ = "Interest"
interestNode.__primarykey__ = "name"
INTERESTED_IN = Relationship.type("INTERESTED_IN")
#Merge combines if already exists, else creates new
register.merge(
INTERESTED_IN(userNode, interestNode, weight=interestLevel))
i += 1
j += 1
if (i == 4): #submits a batch every 4 lines read
register.commit()
print(j, "interest lines processed")
i = 0
register = graph.begin()
else:
register.commit() #submits remainder of lines read
print(j, "interest lines processed")
except Exception as e:
print(e, row, reader.line_num)
def gregorian_calendar(graph, time1=None, node1=None):
if time1 is None:
time1 = datetime.now()
# gregorian calendar node
gregorian_node = Node("Calendar", calendar_type="Gregorian")
gregorian_node.__primarylabel__ = list(gregorian_node.labels)[0]
gregorian_node.__primarykey__ = "calendar_type"
graph.merge(gregorian_node)
# year node
that_year_node = Node("Year", year=time1.year, key=time1.strftime("%Y"))
that_year_node.__primarylabel__ = list(that_year_node.labels)[0]
that_year_node.__primarykey__ = "year"
graph.merge(that_year_node)
# calendar has year
rel = Relationship(gregorian_node, "YEAR", that_year_node)
graph.merge(rel)
# month node
that_month_node = Node("Month",
month=time1.month,
key=time1.strftime("%m-%Y"))
that_month_node.__primarylabel__ = list(that_month_node.labels)[0]
that_month_node.__primarykey__ = "month"
graph.merge(that_month_node)
# year has month
rel = Relationship(that_year_node, "MONTH", that_month_node)
graph.merge(rel)
# day node
that_day_node = Node("Day", day=time1.day, key=time1.strftime("%d-%m-%Y"))
that_day_node.__primarylabel__ = list(that_day_node.labels)[0]
that_day_node.__primarykey__ = "day"
graph.merge(that_day_node)
# month has day
rel = Relationship(that_month_node, "DAY", that_day_node)
graph.merge(rel)
# post was published on (gregorian) day
if node1 is not None:
rel = Relationship(node1, "ON", that_day_node)
graph.create(rel)
def create_node(self, prov_object):
node_data = prov_object.to_dict()
label = node_data.pop('label')
node = Node(label, **node_data)
node.__primarylabel__ = label
node.__primarykey__ = 'id'
self.graph.merge(node)
logger.debug("Created node: {}".format(node))
def create_URL_node(self, url) -> Node:
url_node = Node('URL',
url=url['url'],
expanded_url=url['expanded_url'],
display_url=url['display_url'])
url_node.__primarykey__ = 'url'
url_node.__primarylabel__ = 'URL'
return url_node
def update_node(node):
if node.get("labels") in ('', None) or node.get("name") in ('', None):
return None, 201
node_find = find_node(node.get("labels"), node.get("name"))
print(node_find)
# print(node_find)
if node_find not in ('', None):
nodes = NodeObject(node.get("labels"))
nodes.name = node.get("name")
nodes.full_name = node.get("full_name")
# if full_name == '':
# full_name = ''
nodes.image = node.get("image")
# if image == '':
# image = ''
nodes.object_id = node.get("object_id")
# if object_id == 0:
# object_id = ''
nodes.weight = node.get("weight")
# if weight == 0:
# weight = ''
nodes.keywords = node.get("keywords")
# if keywords == '':
# keywords = ''
type1 = node.get("type")
nodes.date_time = node.get("date_time")
# if date_time == '':
# date_time = ''
# node_temp = Node(labels, name=name, full_name=full_name, image=image, object_id=object_id,
# weight=weight, keywords=keywords, date_time=date_time)
# node_temp.__primarylabel__ = labels
# node_temp.__primarykey__ = name
graph = neo4j_connect()
transaction = graph.begin()
# transaction.merge(node_temp, labels, "name", name)
graph.merge(nodes)
graph.push(nodes)
graph.run(
"MATCH(n:event)-[r]->(p:event_category) detach delete r, p return p"
)
if type1 not in ('', None):
event_type = Node("event_category", name=type1)
event_type.__primarylabel__ = "event_category"
event_type.__primarykey__ = type1
transaction.create(event_type)
rels_event = Relationship(nodes.__node__,
"Belong to the type of event",
event_type)
transaction.create(rels_event)
transaction.commit()
transaction.finished()
cypher = """MATCH path = (n:`{labels}`)-[]-() where n.name = '{name}' """.format(
labels=nodes.__primarylabel__, name=nodes.name)
result = export_json_run_cypher(cypher)
return result
def graph_organization(self, org):
"""Create a graph node for a GCP organization."""
logging.info("Graphing organization " + org.name)
org_node = Node("organization", name=org.name, id=org.id)
org_node.__primarylabel__ = "organization"
org_node.__primarykey__ = "name"
for folder in org.get_folders():
self.graph_folder(folder, org_node)
for project in org.get_projects():
self.graph_project(project, org_node)
def _create_collection_hub_node(self, member_label_name, hub_id):
hub_node_label = self._get_hub_node_label_name(member_label_name)
hub_node = Node(hub_node_label, id=hub_id)
hub_node._is_collectionhub = True
hub_node.__primarylabel__ = hub_node_label
hub_node.__primarykey__ = "id"
for lbl in self.config_list_collection_anchor_extra_labels:
hub_node.add_label(lbl)
if self.config_str_collection_anchor_attach_list_members_label:
hub_node.add_label(member_label_name)
return hub_node
def set_people_and_university_relationship(self, people, university):
if isinstance(people, str): people = json.loads(people)
people_node = Node("Pessoa",
Nome=people['nome'],
DataDeNascimento=people['data_nascimento'],
Email=people['email'],
Cidade=people['cidade'],
Estado=people['estado'],
Cargo=people['cargo'])
people_node.__primarylabel__ = "Pessoa"
people_node.__primarykey__ = "Nome"
if isinstance(university, str): university = json.loads(university)
university_node = Node("Universidade",
Nome=university['nome'],
Cidade=university['cidade'],
Estado=university['estado'])
university_node.__primarylabel__ = "Universidade"
university_node.__primarykey__ = "Nome"
relationship = Relationship.type("ESTUDA")
self._graph.merge(relationship(people_node, university_node))
def dynamic_neighbors(self, router):
ospf_info = self.snmp2json[self.NetElement][u'L3Domain'][u'OSPF_INFO']
bgp_info = self.snmp2json[self.NetElement][u'L3Domain'][u'BGP_INFO']
if ospf_info['Router_Id']:
router['Router_Id'] = ospf_info['Router_Id']
graph.push(router)
ospf_areas = ospf_info['Areas']
ospf_neigh = ospf_info['Neighbors']
for area in ospf_areas:
area_id = ospf_areas[area]['AreaId']
area_status = ospf_areas[area]['AreaStatus']
area_auth_type = ospf_areas[area]['AuthType']
ospf_area_node = Node('Ospf_Area', id = area_id, status = area_status, auth = area_auth_type)
ospf_area_node.__primarylabel__ = 'Ospf_Area'
ospf_area_node.__primarykey__ = 'id'
PART_OF = Relationship.type('PART_OF')
rel_router_int = graph.merge(PART_OF(router,ospf_area_node))
for neighbor in ospf_neigh:
neigh_id = ospf_neigh[neighbor]['NbrRtrId']
neigh_ip = ospf_neigh[neighbor]['NbrIpAddr']
neigh_state = ospf_neigh[neighbor]['NbrState']
ip = Node('Ip_address', status = 'Active', address = neigh_ip)
ip.__primarylabel__ = "Ip_address"
ip.__primarykey__ = "address"
OSPF_NEIGHBOR = Relationship.type('OSPF_NEIGHBOR')
rel_ospf_router = graph.merge(OSPF_NEIGHBOR(router,ip, state = neigh_state, neigh_rt_id = neigh_id))
if bgp_info['LocalAs']:
router['LocalAs'] = bgp_info['LocalAs']
graph.push(router)
bgp_peers = bgp_info['Peers']
for peer in bgp_peers:
peer_local_add = bgp_peers[peer]['PeerLocalAddr']
peer_id = bgp_peers[peer]['PeerIdentifier']
peer_as = bgp_peers[peer]['PeerRemoteAs']
peer_address = bgp_peers[peer]['PeerRemoteAddr']
peer_state = bgp_peers[peer]['PeerState']
ip = Node('Ip_address', status = 'Active', address = peer_address)
ip.__primarylabel__ = "Ip_address"
ip.__primarykey__ = "address"
BGP_PEER = Relationship.type('BGP_PEER')
rel_bgp_router = graph.merge(BGP_PEER(router, ip, state = peer_state, peer_rt_id = peer_id))
def test_merge_with_primary_key_list(self):
a = Node("A", a=1)
b = Node("B", b=2)
self.graph.create(a | b)
a_id = remote(a)._id
b_id = remote(b)._id
node = Node("A", "B", a=1, b=2)
node.__primarylabel__ = "B"
node.__primarykey__ = ["b"]
self.graph.merge(node, "A", "a")
assert remote(node)._id != a_id
assert remote(node)._id == b_id
def test_merge_with_magic_values_overrides_arguments(self):
a = Node("A", a=1)
b = Node("B", b=2)
self.graph.create(a | b)
a_id = remote(a)._id
b_id = remote(b)._id
node = Node("A", "B", a=1, b=2)
node.__primarylabel__ = "B"
node.__primarykey__ = "b"
self.graph.merge(node, "A", "a")
assert remote(node)._id != a_id
assert remote(node)._id == b_id
def set_people_and_company_relationship(self, people, company):
if isinstance(people, str): people = json.loads(people)
people_node = Node("Pessoa",
Nome=people['nome'],
DataDeNascimento=people['data_nascimento'],
Email=people['email'],
Cidade=people['cidade'],
Estado=people['estado'],
Cargo=people['cargo'])
people_node.__primarylabel__ = "Pessoa"
people_node.__primarykey__ = "Nome"
if isinstance(company, str): company = json.loads(company)
company_node = Node("Empresa",
Nome=company['nome'],
Cidade=company['cidade'],
Estado=company['estado'],
Area=company['area'])
company_node.__primarylabel__ = "Empresa"
company_node.__primarykey__ = "Nome"
relationship = Relationship.type("TRABALHA")
self._graph.merge(relationship(people_node, company_node))
def get_character(message):
if message['AuctionType'] == 'request':
char_id = message['BuyerCharacterId']
char_name = message['BuyerName']
elif message['AuctionType'] == 'offer':
char_id = message['SellerCharacterId']
char_name = message['SellerName']
char_node = Node('Character', Id=char_id, Name=char_name)
char_node.__primarylabel__ = 'Character'
char_node.__primarykey__ = 'Id'
return char_node
def create_event(events):
# print(object)
# event = NodeObject("event")
name = events.get('name')
full_name = events.get("full_name")
image = events.get("image")
object_id = events.get("object_id")
weight = events.get("weight")
type1 = events.get("type")
location = events.get("location")
date_time = events.get("date_time")
keywords = events.get("keywords")
graph = neo4j_connect()
event_find = graph.nodes.match("Event", name=name).first()
if event_find not in ('', None):
return ("Event da ton tai")
pattern = """ Create(m:Event{{name:'{name}', full_name:'{full_name}', image:'{image}', object_id:{object_id}, weight:{weight}, location:'{location}', date_time: datetime("{date_time}"), keywords:'{keywords}'}}) return m"""
pattern = pattern.format(name=name,
full_name=full_name,
image=image,
object_id=object_id,
weight=weight,
location=location,
date_time=date_time,
keywords=keywords)
print(pattern)
graph.run(pattern)
event = graph.nodes.match("Event", name=name).first()
print(event)
transaction = graph.begin()
if type1 not in ('', None):
event_type = Node("Event_Category", name=type1)
event_type.__primarylabel__ = "Event_Category"
event_type.__primarykey__ = type
transaction.create(event_type)
rels_event = Relationship(event, "BELONG TYPE OF EVENT", event_type)
transaction.create(rels_event)
#Create rels event category
object = events.get("object")
if len(object) not in ('', None):
for x in object.split(","):
if x not in ('', None):
object_find = graph.nodes.match(name=x.strip()).first()
transaction.create(
Relationship(object_find, events.get("object_rels"),
event))
transaction.commit()
transaction.finished()
return event
def test_merge_with_magic_values_overrides_arguments(graph, make_unique_id):
label_a = make_unique_id()
label_b = make_unique_id()
a = Node(label_a, a=1)
b = Node(label_b, b=2)
graph.create(a | b)
a_id = a.identity
b_id = b.identity
node = Node(label_a, label_b, a=1, b=2)
node.__primarylabel__ = label_b
node.__primarykey__ = "b"
graph.merge(node, label_a, "a")
assert node.identity != a_id
assert node.identity == b_id
def test_can_merge_node_with_primary_key_overriding_model(graph):
from py2neo.ogm import Model
class Person(Model):
__primarylabel__ = "Person"
__primarykey__ = "nom"
graph.delete_all()
a = Node("Person", name="Alice")
a.__model__ = Person
a.__primarykey__ = "name"
graph.merge(a)
assert graph.nodes.match("Person", name="Alice").first() == a
def graph_service_account(self, service_account, parent_node):
"""Create a graph node for a service account."""
node = Node("service_account",
name=service_account.email,
id=service_account.id)
node.__primarylabel__ = "service_account"
node.__primarykey__ = "name"
relationship = Relationship.type("sa_child_of")
try:
self.graph.merge(relationship(node, parent_node))
except ConnectionRefusedError as e:
logging.error(str(e))
logging.error("Unable to connect to the graph service, exiting.")
sys.exit()
def new_router_node(self):
self.api_call()
if 'message' not in self.snmp2json:
self.hostname = self.snmp2json[self.NetElement][u'DevInfo'][u'hostname']
self.dev_info = self.snmp2json[self.NetElement][u'DevInfo'][u'description']
self.vlans = self.snmp2json[self.NetElement][u'L2Domain'][u'Vlans']
router = Node('Router', hostname = self.hostname, devinfo = self.dev_info, vlans = list(self.vlans))
router.__primarylabel__ = "Router"
router.__primarykey__ = "hostname"
if not self.find_router(self.hostname):
graph.create(router)
self.new_interfaces_node(router)
self.new_arp_neighbor_rel(router)
self.new_network_node(router)
self.dynamic_neighbors(router)
def new_ip_addr_node(self):
ip_addresses = self.snmp2json[self.NetElement][u'L3Domain'][u'IPs']
for i in ip_addresses:
int_id = i
for j in ip_addresses[i]:
if not '127.0.0.' in j:
if not self.find_ip_addr(j):
ip = Node('Ip_address',int_id = int_id, status = 'Active', address = j)
ip.__primarylabel__ = "Ip_address"
ip.__primarykey__ = "address"
graph.create(ip)
query = '''MATCH (i:Interface)-[:BELONGS_TO]->(r:Router), (ip:Ip_address)
WHERE ((r.hostname = {hostname} and i.int_id = {int_id}) and ip.address = {address})
CREATE UNIQUE (ip)-[:CONFIGURED_IN]->(i) '''
rel_ip_int = graph.run(query, hostname = self.hostname, int_id = int_id, address = j )
def create_vis_node(vis_node: VisNode):
print('GraphService: create_vis_node: vis_node = ', vis_node)
n_vis = Node('Vis',
name=vis_node.name,
description=vis_node.description)
n_vis.__primarylabel__ = "Vis"
n_vis.__primarykey__ = "name"
tx = graph.begin()
n_vis_type = GraphService.create_vis_type_node(vis_node.vis_type)
r_vis_vis_type = Relationship(n_vis, 'VIS_TYPE', n_vis_type)
tx.merge(r_vis_vis_type)
tx.commit()
def get_character(message): if message['AuctionType'] == 'request': char_id = message['BuyerCharacterId'] char_name = message['BuyerName'] elif message['AuctionType'] == 'offer': char_id = message['SellerCharacterId'] char_name = message['SellerName'] char_node = Node( 'Character', Id = char_id, Name = char_name ) char_node.__primarylabel__ = 'Character' char_node.__primarykey__ = 'Id' return char_node
def get_item(message):
group = message['ItemGroupTypeId']
enchantment = message['EnchantmentLevel']
quality = message['QualityLevel']
item_id = f"{group}@{enchantment}&{quality}"
item_node = Node(
'Item',
Id = item_id,
Group = message['ItemGroupTypeId'],
Tier = message['Tier'],
Enchantment = enchantment,
Quality = quality
)
item_node.__primarylabel__ = "Item"
item_node.__primarykey__ = 'Id'
return item_node
