-
Notifications
You must be signed in to change notification settings - Fork 1
/
spacedata.go
144 lines (132 loc) · 4.47 KB
/
spacedata.go
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package spacedb
import (
"github.com/freddy33/qsm-go/backend/m3db"
"github.com/freddy33/qsm-go/backend/pathdb"
"github.com/freddy33/qsm-go/backend/pointdb"
"github.com/freddy33/qsm-go/m3util"
"github.com/freddy33/qsm-go/model/m3space"
)
type ServerSpacePackData struct {
m3space.BaseSpacePackData
env *m3db.QsmDbEnvironment
spacesTe *m3db.TableExec
eventsTe *m3db.TableExec
nodesTe *m3db.TableExec
allSpaces map[int]*SpaceDb
allSpacesLoaded bool
}
func (spaceData *ServerSpacePackData) CreateSpace(name string, activePathNodeThreshold m3space.DistAndTime, maxTriosPerPoint int, maxPathNodesPerPoint int) (m3space.SpaceIfc, error) {
return CreateSpace(spaceData.env, name, activePathNodeThreshold, maxTriosPerPoint, maxPathNodesPerPoint)
}
func (spaceData *ServerSpacePackData) DeleteSpace(id int, name string) (int, error) {
err := spaceData.LoadAllSpaces()
if err != nil {
return 0, err
}
space, ok := spaceData.allSpaces[id]
if !ok {
return 0, m3util.MakeQsmErrorf("Space id %d not found!", id)
}
if space.GetName() != name {
return 0, m3util.MakeQsmErrorf("Space id %d name is %q not %q!", id, space.GetName(), name)
}
totalDeleted := 0
eventIds := space.GetEventIdsForMsg()
for _, evtId := range eventIds {
// TODO: Needs to go distance by distance backwards to avoid dead locks on node links
nbNodes, err := spaceData.nodesTe.Update(DeleteAllNodes, evtId)
totalDeleted += nbNodes
if err != nil {
return totalDeleted, m3util.MakeWrapQsmErrorf(err, "failed to delete nodes of %s event id %d due to %s", space.String(), evtId, err.Error())
}
}
Log.Infof("Deleted %d nodes from space %s", totalDeleted, space.String())
nbEvents, err := spaceData.eventsTe.Update(DeleteAllEvents, space.GetId())
totalDeleted += nbEvents
if err != nil {
return totalDeleted, m3util.MakeWrapQsmErrorf(err, "failed to delete events of %s due to %s", space.String(), err.Error())
}
Log.Infof("Deleted %d events from space %s", nbEvents, space.String())
nbSpaces, err := spaceData.spacesTe.Update(DeleteSpace, space.GetId(), space.GetName())
totalDeleted += nbSpaces
if err != nil {
return totalDeleted, m3util.MakeWrapQsmErrorf(err, "failed to delete space %s due to %s", space.String(), err.Error())
}
Log.Infof("Deleted %d space from space %s", nbSpaces, space.String())
if nbSpaces != 1 {
Log.Errorf("Should have deleted only 1 space not %d", nbSpaces)
}
delete(spaceData.allSpaces, id)
return totalDeleted, nil
}
func (spaceData *ServerSpacePackData) GetAllSpaces() []m3space.SpaceIfc {
err := spaceData.LoadAllSpaces()
if err != nil {
Log.Error(err)
return nil
}
res := make([]m3space.SpaceIfc, len(spaceData.allSpaces))
i := 0
for _, s := range spaceData.allSpaces {
res[i] = s
i++
}
return res
}
func (spaceData *ServerSpacePackData) TableInited() bool {
return spaceData.spacesTe != nil && spaceData.eventsTe != nil && spaceData.nodesTe != nil
}
func (spaceData *ServerSpacePackData) LoadAllSpaces() error {
if spaceData.allSpacesLoaded {
return nil
}
pathData := pathdb.GetServerPathPackData(spaceData.env)
pointData := pointdb.GetServerPointPackData(spaceData.env)
rows, err := spaceData.spacesTe.SelectAllForLoad()
if err != nil {
return err
}
for rows.Next() {
space := SpaceDb{spaceData: spaceData, pathData: pathData, pointData: pointData}
err := rows.Scan(&space.id, &space.name, &space.activeThreshold,
&space.maxTriosPerPoint, &space.maxNodesPerPoint, &space.maxCoord, &space.maxTime)
if err != nil {
return err
}
existingSpace, ok := spaceData.allSpaces[space.id]
if ok {
// Make sure same data
if existingSpace.name != space.name {
return m3util.MakeQsmErrorf("got different spaces in memory %v and DB %v", existingSpace, space)
}
} else {
err = space.finalInit()
if err != nil {
return err
}
}
}
spaceData.allSpacesLoaded = true
return nil
}
func (spaceData *ServerSpacePackData) GetSpace(id int) m3space.SpaceIfc {
err := spaceData.LoadAllSpaces()
if err != nil {
Log.Error(err)
return nil
}
return spaceData.allSpaces[id]
}
func makeServerSpacePackData(env m3util.QsmEnvironment) *ServerSpacePackData {
res := new(ServerSpacePackData)
res.EnvId = env.GetId()
res.env = env.(*m3db.QsmDbEnvironment)
res.allSpaces = make(map[int]*SpaceDb, 3)
return res
}
func GetServerSpacePackData(env m3util.QsmEnvironment) *ServerSpacePackData {
if env.GetData(m3util.SpaceIdx) == nil {
env.SetData(m3util.SpaceIdx, makeServerSpacePackData(env))
}
return env.GetData(m3util.SpaceIdx).(*ServerSpacePackData)
}