/
store.go
193 lines (175 loc) · 4.54 KB
/
store.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
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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
package mgou
import (
"errors"
"labix.org/v2/mgo"
"labix.org/v2/mgo/bson"
"sync"
. "github.com/araddon/gou"
)
var (
mgo_conn string
mgoMu sync.Mutex
mgoSessions = make(map[string]*MgoSession)
)
func SetMongoInfo(conn string) {
mgoMu.Lock()
defer mgoMu.Unlock()
mgo_conn = conn
}
type MgoSession struct {
S *mgo.Session
Ct int
}
func MgoConnCheckin(s *mgo.Session) {
}
// Manages creation of Mongo Connections w locking etc
func MgoConnGet(name string) (*mgo.Session, error) {
var s *MgoSession
var found bool
mgoMu.Lock()
defer mgoMu.Unlock()
if s, found = mgoSessions[name]; !found {
s = new(MgoSession)
session, err := mgo.Dial(mgo_conn)
if err != nil {
Logf(ERROR, "MGOU Error on mgou ? name=%s conn='%s' er=%v", name, mgo_conn, err)
return nil, err
} else {
s.S = session
}
mgoSessions[name] = s
}
if s.S != nil {
return s.S.Copy(), nil
}
return nil, errors.New("no session created")
}
// Save the DataModel to DataStore
func Insert(mgo_db string, m DataModel, conn *mgo.Session) (err error) {
if conn == nil {
conn, err = MgoConnGet(mgo_db)
if err != nil {
return
}
defer conn.Close()
}
if conn != nil {
c := conn.DB(mgo_db).C(m.Type())
if len(m.MidGet()) == 0 {
m.MidSet(bson.NewObjectId())
}
if err = c.Insert(m); err != nil {
Log(ERROR, "MGOU ERROR on insert ", err, " TYPE=", m.Type(), " ", m.MidGet())
} else {
//Log(DEBUG, "successfully inserted!!!!!! ", m.MidGet(), " oid=", m.OidGet())
}
} else {
Log(ERROR, "MGOU Nil connection")
return errors.New("no db connection")
}
return
}
// Save the DataModel to DataStore
func SaveModel(mgo_db string, m DataModel, conn *mgo.Session) (err error) {
if conn == nil {
conn, err = MgoConnGet(mgo_db)
if err != nil {
return
}
defer conn.Close()
}
if conn != nil {
bsonMid := m.MidGet()
c := conn.DB(mgo_db).C(m.Type())
//Debug("SAVING ", mgo_db, " type=", m.Type(), " Mid=", bsonMid)
if len(bsonMid) < 5 {
m.MidSet(bson.NewObjectId())
if err = c.Insert(m); err != nil {
Log(ERROR, "MGOU ERROR on insert ", err, " TYPE=", m.Type(), " ", m.MidGet())
} else {
//Log(DEBUG, "successfully inserted!!!!!! ", m.MidGet(), " oid=", m.OidGet())
}
} else {
// YOU MUST NOT SEND Mid "_id" to Mongo
mid := m.MidGet()
m.MidSet("") // omitempty means it doesn't get sent
if err = c.Update(bson.M{"_id": bson.ObjectId(bsonMid)}, m); err != nil {
Log(ERROR, "MGOU ERROR on update ", err, " ", bsonMid, " MID=?", m.MidGet())
}
m.MidSet(mid)
}
} else {
Log(ERROR, "MGOU Nil connection")
return errors.New("no db connection")
}
return
}
func ModelsDelete(mgo_db string, qry interface{}, dm DataModel) error {
if conn, c, ok := GetTableConn(mgo_db, dm); ok {
info, err := c.RemoveAll(qry)
//Debug("MGOU ", info, "delete from table=", dm.Type())
if err != nil {
Log(ERROR, "MGOU could not delete items? ", err, info)
return err
}
conn.Close()
} else {
Log(ERROR, "MGOU Could not get conn for ", dm.Type())
}
return nil
}
// Load single Model
func ModelGet(mgo_db string, qry interface{}, dm DataModel) (err error) {
if conn, c, ok := GetTableConn(mgo_db, dm); ok {
err = c.Find(qry).One(dm)
conn.Close()
} else {
Log(ERROR, "MGOU Could not get conn for ", dm.Type())
err = errors.New("Could not get db conn")
}
return
}
// perform an update
func Update(mgo_db string, selector, update interface{}, dm DataModel) (err error) {
if conn, c, ok := GetTableConn(mgo_db, dm); ok {
if err = c.Update(selector, update); err != nil {
Log(ERROR, "MGOU ERROR on update ", err)
}
conn.Close()
} else {
Log(ERROR, "MGOU Could not get conn for ", dm.Type())
err = errors.New("Could not get db conn")
}
return
}
// Load Models from Mongo
func ModelsLoad(mgo_db string, list interface{}, qry interface{}, dm DataModel) (err error) {
if conn, c, ok := GetTableConn(mgo_db, dm); ok {
iter := c.Find(qry).Iter()
err = iter.All(list)
if err != nil { //&& err.Error() != "not found"
Log(ERROR, err)
}
conn.Close()
} else {
Log(ERROR, "MGOU Could not get conn for ", dm.Type())
err = errors.New("Could not get db conn")
}
return
}
func GetTableConn(mgo_db string, dm DataModel) (s *mgo.Session, c *mgo.Collection, ok bool) {
conn, _ := MgoConnGet(mgo_db)
if conn != nil {
c := conn.DB(mgo_db).C(dm.Type())
return conn, c, true
}
return nil, nil, false
}
func GetMgoCC(mgo_db, name string) (s *mgo.Session, c *mgo.Collection, ok bool) {
conn, _ := MgoConnGet(mgo_db)
if conn != nil {
c := conn.DB(mgo_db).C(name)
return conn, c, true
}
return nil, nil, false
}