Newer
Older
package nodes
import (
"fmt"
"log"
"code.fbi.h-da.de/danet/gosdn/controller/nucleus/database"
"code.fbi.h-da.de/danet/gosdn/controller/nucleus/errors"
"code.fbi.h-da.de/danet/gosdn/controller/topology/store"
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
"github.com/google/uuid"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo/options"
)
// Store defines a NodeStore interface
type Store interface {
Add(Node) error
Update(Node) error
Delete(Node) error
Get(store.Query) (Node, error)
GetAll() ([]Node, error)
}
// DatabaseNodeStore is a database store for nodes
type DatabaseNodeStore struct {
storeName string
}
// NewDatabaseNodeStore returns a NodeStore
func NewDatabaseNodeStore() Store {
return &DatabaseNodeStore{
storeName: fmt.Sprintf("node-store.json"),
}
}
// Get takes a nodes's UUID or name and returns the nodes.
func (s *DatabaseNodeStore) Get(query store.Query) (Node, error) {
var loadedNode Node
if query.ID.String() != "" {
loadedNode, err := s.getByID(query.ID)
if err != nil {
return loadedNode, errors.ErrCouldNotFind{ID: query.ID, Name: query.Name}
}
return loadedNode, nil
}
loadedNode, err := s.getByName(query.Name)
if err != nil {
return loadedNode, errors.ErrCouldNotFind{ID: query.ID, Name: query.Name}
}
return loadedNode, nil
}
func (s *DatabaseNodeStore) getByID(idOfNode uuid.UUID) (Node, error) {
var loadedNode Node
client, ctx, cancel := database.GetMongoConnection()
defer cancel()
defer client.Disconnect(ctx)
db := client.Database(database.DatabaseName)
collection := db.Collection(s.storeName)
result := collection.FindOne(ctx, bson.D{primitive.E{Key: "_id", Value: idOfNode.String()}})
return loadedNode, errors.ErrCouldNotFind{ID: idOfNode}
}
err := result.Decode(&loadedNode)
if err != nil {
log.Printf("Failed marshalling %v", err)
return loadedNode, errors.ErrCouldNotFind{ID: idOfNode}
}
return loadedNode, nil
}
func (s *DatabaseNodeStore) getByName(nameOfNode string) (Node, error) {
var loadedNode Node
client, ctx, cancel := database.GetMongoConnection()
defer cancel()
defer client.Disconnect(ctx)
db := client.Database(database.DatabaseName)
collection := db.Collection(s.storeName)
result := collection.FindOne(ctx, bson.D{primitive.E{Key: "name", Value: nameOfNode}})
return loadedNode, errors.ErrCouldNotFind{Name: nameOfNode}
}
err := result.Decode(&loadedNode)
if err != nil {
log.Printf("Failed marshalling %v", err)
return loadedNode, errors.ErrCouldNotFind{Name: nameOfNode}
}
return loadedNode, nil
}
// GetAll returns all stored nodes.
func (s *DatabaseNodeStore) GetAll() ([]Node, error) {
var loadedNode []Node
client, ctx, cancel := database.GetMongoConnection()
defer cancel()
defer client.Disconnect(ctx)
db := client.Database(database.DatabaseName)
collection := db.Collection(s.storeName)
cursor, err := collection.Find(ctx, bson.D{})
if err != nil {
return []Node{}, err
}
defer cursor.Close(ctx)
err = cursor.All(ctx, &loadedNode)
if err != nil {
log.Printf("Failed marshalling %v", err)
return loadedNode, errors.ErrCouldNotMarshall{Type: loadedNode, Err: err}
}
return loadedNode, nil
}
// Add adds a node to the node store.
func (s *DatabaseNodeStore) Add(node Node) error {
client, ctx, cancel := database.GetMongoConnection()
defer cancel()
defer client.Disconnect(ctx)
_, err := client.Database(database.DatabaseName).
Collection(s.storeName).
InsertOne(ctx, node)
if err != nil {
log.Printf("Could not add Node: %v", err)
return errors.ErrCouldNotCreate{Identifier: node.ID, Type: node, Err: err}
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
}
return nil
}
// Update updates a existing node.
func (s *DatabaseNodeStore) Update(node Node) error {
var updatedLoadedNodes Node
client, ctx, cancel := database.GetMongoConnection()
defer cancel()
defer client.Disconnect(ctx)
update := bson.D{primitive.E{Key: "$set", Value: node}}
upsert := false
after := options.After
opt := options.FindOneAndUpdateOptions{
Upsert: &upsert,
ReturnDocument: &after,
}
err := client.Database(database.DatabaseName).
Collection(s.storeName).
FindOneAndUpdate(
ctx, bson.M{"_id": node.ID.String()}, update, &opt).
Decode(&updatedLoadedNodes)
if err != nil {
log.Printf("Could not update Node: %v", err)
return errors.ErrCouldNotUpdate{Identifier: node.ID, Type: node, Err: err}
}
return nil
}
// Delete deletes a node from the node store.
func (s *DatabaseNodeStore) Delete(node Node) error {
client, ctx, cancel := database.GetMongoConnection()
defer cancel()
defer client.Disconnect(ctx)
db := client.Database(database.DatabaseName)
collection := db.Collection(s.storeName)
_, err := collection.DeleteOne(ctx, bson.D{primitive.E{Key: node.ID.String()}})
if err != nil {
return err
}
return nil
}