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
194
195
196
|
package dbtest
import (
"bytes"
"fmt"
"net"
"os"
"os/exec"
"strconv"
"time"
"gopkg.in/mgo.v2"
"gopkg.in/tomb.v2"
)
// DBServer controls a MongoDB server process to be used within test suites.
//
// The test server is started when Session is called the first time and should
// remain running for the duration of all tests, with the Wipe method being
// called between tests (before each of them) to clear stored data. After all tests
// are done, the Stop method should be called to stop the test server.
//
// Before the DBServer is used the SetPath method must be called to define
// the location for the database files to be stored.
type DBServer struct {
session *mgo.Session
output bytes.Buffer
server *exec.Cmd
dbpath string
host string
tomb tomb.Tomb
}
// SetPath defines the path to the directory where the database files will be
// stored if it is started. The directory path itself is not created or removed
// by the test helper.
func (dbs *DBServer) SetPath(dbpath string) {
dbs.dbpath = dbpath
}
func (dbs *DBServer) start() {
if dbs.server != nil {
panic("DBServer already started")
}
if dbs.dbpath == "" {
panic("DBServer.SetPath must be called before using the server")
}
mgo.SetStats(true)
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
panic("unable to listen on a local address: " + err.Error())
}
addr := l.Addr().(*net.TCPAddr)
l.Close()
dbs.host = addr.String()
args := []string{
"--dbpath", dbs.dbpath,
"--bind_ip", "127.0.0.1",
"--port", strconv.Itoa(addr.Port),
"--nssize", "1",
"--noprealloc",
"--smallfiles",
"--nojournal",
}
dbs.tomb = tomb.Tomb{}
dbs.server = exec.Command("mongod", args...)
dbs.server.Stdout = &dbs.output
dbs.server.Stderr = &dbs.output
err = dbs.server.Start()
if err != nil {
panic(err)
}
dbs.tomb.Go(dbs.monitor)
dbs.Wipe()
}
func (dbs *DBServer) monitor() error {
dbs.server.Process.Wait()
if dbs.tomb.Alive() {
// Present some debugging information.
fmt.Fprintf(os.Stderr, "---- mongod process died unexpectedly:\n")
fmt.Fprintf(os.Stderr, "%s", dbs.output.Bytes())
fmt.Fprintf(os.Stderr, "---- mongod processes running right now:\n")
cmd := exec.Command("/bin/sh", "-c", "ps auxw | grep mongod")
cmd.Stdout = os.Stderr
cmd.Stderr = os.Stderr
cmd.Run()
fmt.Fprintf(os.Stderr, "----------------------------------------\n")
panic("mongod process died unexpectedly")
}
return nil
}
// Stop stops the test server process, if it is running.
//
// It's okay to call Stop multiple times. After the test server is
// stopped it cannot be restarted.
//
// All database sessions must be closed before or while the Stop method
// is running. Otherwise Stop will panic after a timeout informing that
// there is a session leak.
func (dbs *DBServer) Stop() {
if dbs.session != nil {
dbs.checkSessions()
if dbs.session != nil {
dbs.session.Close()
dbs.session = nil
}
}
if dbs.server != nil {
dbs.tomb.Kill(nil)
dbs.server.Process.Signal(os.Interrupt)
select {
case <-dbs.tomb.Dead():
case <-time.After(5 * time.Second):
panic("timeout waiting for mongod process to die")
}
dbs.server = nil
}
}
// Session returns a new session to the server. The returned session
// must be closed after the test is done with it.
//
// The first Session obtained from a DBServer will start it.
func (dbs *DBServer) Session() *mgo.Session {
if dbs.server == nil {
dbs.start()
}
if dbs.session == nil {
mgo.ResetStats()
var err error
dbs.session, err = mgo.Dial(dbs.host + "/test")
if err != nil {
panic(err)
}
}
return dbs.session.Copy()
}
// checkSessions ensures all mgo sessions opened were properly closed.
// For slightly faster tests, it may be disabled setting the
// environmnet variable CHECK_SESSIONS to 0.
func (dbs *DBServer) checkSessions() {
if check := os.Getenv("CHECK_SESSIONS"); check == "0" || dbs.server == nil || dbs.session == nil {
return
}
dbs.session.Close()
dbs.session = nil
for i := 0; i < 100; i++ {
stats := mgo.GetStats()
if stats.SocketsInUse == 0 && stats.SocketsAlive == 0 {
return
}
time.Sleep(100 * time.Millisecond)
}
panic("There are mgo sessions still alive.")
}
// Wipe drops all created databases and their data.
//
// The MongoDB server remains running if it was prevoiusly running,
// or stopped if it was previously stopped.
//
// All database sessions must be closed before or while the Wipe method
// is running. Otherwise Wipe will panic after a timeout informing that
// there is a session leak.
func (dbs *DBServer) Wipe() {
if dbs.server == nil || dbs.session == nil {
return
}
dbs.checkSessions()
sessionUnset := dbs.session == nil
session := dbs.Session()
defer session.Close()
if sessionUnset {
dbs.session.Close()
dbs.session = nil
}
names, err := session.DatabaseNames()
if err != nil {
panic(err)
}
for _, name := range names {
switch name {
case "admin", "local", "config":
default:
err = session.DB(name).DropDatabase()
if err != nil {
panic(err)
}
}
}
}
|
