Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package database
import (
"log"
"github.com/neo4j/neo4j-go-driver/neo4j"
)
//Database
type Database struct {
driver neo4j.Driver
session neo4j.Session
}
//NewDatabaseClient creates a database client
func NewDatabaseClient(uri, username, password string, encrypted bool) Database {
//TODO: defer close()?
// probably pretty nasty since it creates copies
driver := createDriver(uri, username, password, encrypted)
session := createSession(driver)
return Database{
driver: driver,
session: session,
}
}
//createDriver creates a neo4j.Driver instance
func createDriver(uri, username, password string, encrypted bool) neo4j.Driver {
driver, err := neo4j.NewDriver(
uri,
neo4j.BasicAuth(username, password, ""),
func(c *neo4j.Config) {
c.Encrypted = encrypted
},
)
logError("failed creating database Driver", err)
return driver
}
//createSession creates a neo4j.Session
func createSession(driver neo4j.Driver) neo4j.Session {
sessionConfig := neo4j.SessionConfig{AccessMode: neo4j.AccessModeWrite}
session, err := driver.NewSession(sessionConfig)
logError("failed creating database session", err)
return session
}
//StoreNodes stores the given nodes to the database
func (d Database) StoreNodes(json string) {
session := d.session
query :=
`
WITH apoc.convert.fromJsonMap($stringToAdd)
AS value
UNWIND value.data as d
MERGE (device:Device {id: d.object_id})
ON CREATE SET device.nativeName = d.object_data.name[0].value,
device.deviceType = d.object_data.name[1].value,
device.serialNumber = d.object_data.name[2].value,
device.softwareVersion = d.object_data.name[3].value,
device.` + "`operational-state` = d.object_data.`operational-state`"
_, err := session.Run(
query, map[string]interface{}{
"stringToAdd": json,
})
logError("failed storing Nodes into database", err)
log.Printf("successfully added Nodes into database")
}
//StoreNodeEdgePoints stores the given node edge points (interfaces)
func (d Database) StoreNodeEdgePoints(json string) {
session := d.session
queryEdgePoints :=
`
WITH apoc.convert.fromJsonMap($stringToAdd)
AS value
UNWIND value.data as i
MERGE (interface:Interface {id: i.object_id})
ON CREATE SET interface.object_type =i.object_type,
interface.localId = i.object_data.name[0].value,
interface.location = i.object_data.name[1].value,
interface.` + "`containing-node` = i.object_data.`containing-node`"
_, err := session.Run(
queryEdgePoints, map[string]interface{}{
"stringToAdd": json,
})
logError("failed storing NodeEdgePoints into database", err)
setNodeNodeEdgePointsRelation(session)
log.Printf("successfully added NodeEdgePoints into database")
}
//setNodeNodeEdgePointsRelation creates the database relations between "nodes" and "node edge points"
func setNodeNodeEdgePointsRelation(session neo4j.Session) {
query :=
`
MATCH (d:Device), (i:Interface)
WHERE d.id = i.` + "`containing-node`" + `
CREATE (i)-[:BELONGS_TO]->(d)
`
_, err := session.Run(
query, map[string]interface{}{})
logError("failed storing NodeNodeEdgePointsRelation into database", err)
log.Printf("successfully stored NodeNodeEdgePointsRelation into database")
}
//logError logs error with custom and error message
func logError(message string, err error) {
if err != nil {
log.Fatalf("%v: %v", message, err)
}
}