← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/gopkg.in/mgo.v2/testserver/testserver.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gopkg.in/mgo.v2/testserver/testserver.go
 
1
// WARNING: This package was replaced by mgo.v2/dbtest.
 
2
package testserver
 
3
 
 
4
import (
 
5
        "bytes"
 
6
        "fmt"
 
7
        "net"
 
8
        "os"
 
9
        "os/exec"
 
10
        "strconv"
 
11
        "time"
 
12
 
 
13
        "gopkg.in/mgo.v2"
 
14
        "gopkg.in/tomb.v2"
 
15
)
 
16
 
 
17
// WARNING: This package was replaced by mgo.v2/dbtest.
 
18
type TestServer struct {
 
19
        session *mgo.Session
 
20
        output  bytes.Buffer
 
21
        server  *exec.Cmd
 
22
        dbpath  string
 
23
        host    string
 
24
        tomb    tomb.Tomb
 
25
}
 
26
 
 
27
// WARNING: This package was replaced by mgo.v2/dbtest.
 
28
func (ts *TestServer) SetPath(dbpath string) {
 
29
        ts.dbpath = dbpath
 
30
}
 
31
 
 
32
func (ts *TestServer) start() {
 
33
        if ts.server != nil {
 
34
                panic("TestServer already started")
 
35
        }
 
36
        if ts.dbpath == "" {
 
37
                panic("TestServer.SetPath must be called before using the server")
 
38
        }
 
39
        mgo.SetStats(true)
 
40
        l, err := net.Listen("tcp", "127.0.0.1:0")
 
41
        if err != nil {
 
42
                panic("unable to listen on a local address: " + err.Error())
 
43
        }
 
44
        addr := l.Addr().(*net.TCPAddr)
 
45
        l.Close()
 
46
        ts.host = addr.String()
 
47
 
 
48
        args := []string{
 
49
                "--dbpath", ts.dbpath,
 
50
                "--bind_ip", "127.0.0.1",
 
51
                "--port", strconv.Itoa(addr.Port),
 
52
                "--nssize", "1",
 
53
                "--noprealloc",
 
54
                "--smallfiles",
 
55
                "--nojournal",
 
56
        }
 
57
        ts.tomb = tomb.Tomb{}
 
58
        ts.server = exec.Command("mongod", args...)
 
59
        ts.server.Stdout = &ts.output
 
60
        ts.server.Stderr = &ts.output
 
61
        err = ts.server.Start()
 
62
        if err != nil {
 
63
                panic(err)
 
64
        }
 
65
        ts.tomb.Go(ts.monitor)
 
66
        ts.Wipe()
 
67
}
 
68
 
 
69
func (ts *TestServer) monitor() error {
 
70
        ts.server.Process.Wait()
 
71
        if ts.tomb.Alive() {
 
72
                // Present some debugging information.
 
73
                fmt.Fprintf(os.Stderr, "---- mongod process died unexpectedly:\n")
 
74
                fmt.Fprintf(os.Stderr, "%s", ts.output.Bytes())
 
75
                fmt.Fprintf(os.Stderr, "---- mongod processes running right now:\n")
 
76
                cmd := exec.Command("/bin/sh", "-c", "ps auxw | grep mongod")
 
77
                cmd.Stdout = os.Stderr
 
78
                cmd.Stderr = os.Stderr
 
79
                cmd.Run()
 
80
                fmt.Fprintf(os.Stderr, "----------------------------------------\n")
 
81
 
 
82
                panic("mongod process died unexpectedly")
 
83
        }
 
84
        return nil
 
85
}
 
86
 
 
87
// WARNING: This package was replaced by mgo.v2/dbtest.
 
88
func (ts *TestServer) Stop() {
 
89
        if ts.session != nil {
 
90
                ts.checkSessions()
 
91
                if ts.session != nil {
 
92
                        ts.session.Close()
 
93
                        ts.session = nil
 
94
                }
 
95
        }
 
96
        if ts.server != nil {
 
97
                ts.tomb.Kill(nil)
 
98
                ts.server.Process.Kill()
 
99
                select {
 
100
                case <-ts.tomb.Dead():
 
101
                case <-time.After(5 * time.Second):
 
102
                        panic("timeout waiting for mongod process to die")
 
103
                }
 
104
                ts.server = nil
 
105
        }
 
106
}
 
107
 
 
108
// WARNING: This package was replaced by mgo.v2/dbtest.
 
109
func (ts *TestServer) Session() *mgo.Session {
 
110
        if ts.server == nil {
 
111
                ts.start()
 
112
        }
 
113
        if ts.session == nil {
 
114
                mgo.ResetStats()
 
115
                var err error
 
116
                ts.session, err = mgo.Dial(ts.host + "/test")
 
117
                if err != nil {
 
118
                        panic(err)
 
119
                }
 
120
        }
 
121
        return ts.session.Copy()
 
122
}
 
123
 
 
124
// WARNING: This package was replaced by mgo.v2/dbtest.
 
125
func (ts *TestServer) checkSessions() {
 
126
        if check := os.Getenv("CHECK_SESSIONS"); check == "0" || ts.server == nil || ts.session == nil {
 
127
                return
 
128
        }
 
129
        ts.session.Close()
 
130
        ts.session = nil
 
131
        for i := 0; i < 100; i++ {
 
132
                stats := mgo.GetStats()
 
133
                if stats.SocketsInUse == 0 && stats.SocketsAlive == 0 {
 
134
                        return
 
135
                }
 
136
                time.Sleep(100 * time.Millisecond)
 
137
        }
 
138
        panic("There are mgo sessions still alive.")
 
139
}
 
140
 
 
141
// WARNING: This package was replaced by mgo.v2/dbtest.
 
142
func (ts *TestServer) Wipe() {
 
143
        if ts.server == nil || ts.session == nil {
 
144
                return
 
145
        }
 
146
        ts.checkSessions()
 
147
        sessionUnset := ts.session == nil
 
148
        session := ts.Session()
 
149
        defer session.Close()
 
150
        if sessionUnset {
 
151
                ts.session.Close()
 
152
                ts.session = nil
 
153
        }
 
154
        names, err := session.DatabaseNames()
 
155
        if err != nil {
 
156
                panic(err)
 
157
        }
 
158
        for _, name := range names {
 
159
                switch name {
 
160
                case "admin", "local", "config":
 
161
                default:
 
162
                        err = session.DB(name).DropDatabase()
 
163
                        if err != nil {
 
164
                                panic(err)
 
165
                        }
 
166
                }
 
167
        }
 
168
}