func (s *S) TearDownTest(c *C) {
if s.stopped {
s.StartAll()
}
for _, host := range s.frozen {
if host != "" {
s.Thaw(host)
}
}
var stats mgo.Stats
for i := 0; ; i++ {
stats = mgo.GetStats()
if stats.SocketsInUse == 0 && stats.SocketsAlive == 0 {
break
}
if i == 20 {
c.Fatal("Test left sockets in a dirty state")
}
c.Logf("Waiting for sockets to die: %d in use, %d alive", stats.SocketsInUse, stats.SocketsAlive)
time.Sleep(500 * time.Millisecond)
}
for i := 0; ; i++ {
stats = mgo.GetStats()
if stats.Clusters == 0 {
break
}
if i == 60 {
c.Fatal("Test left clusters alive")
}
c.Logf("Waiting for clusters to die: %d alive", stats.Clusters)
time.Sleep(1 * time.Second)
}
}
func (s *S) TestTopologySyncWithSlaveSeed(c *C) {
// That's supposed to be a slave. Must run discovery
// and find out master to insert successfully.
session, err := mgo.Dial("localhost:40012")
c.Assert(err, IsNil)
defer session.Close()
coll := session.DB("mydb").C("mycoll")
coll.Insert(M{"a": 1, "b": 2})
result := struct{ Ok bool }{}
err = session.Run("getLastError", &result)
c.Assert(err, IsNil)
c.Assert(result.Ok, Equals, true)
// One connection to each during discovery. Master
// socket recycled for insert.
stats := mgo.GetStats()
c.Assert(stats.MasterConns, Equals, 1)
c.Assert(stats.SlaveConns, Equals, 2)
// Only one socket reference alive, in the master socket owned
// by the above session.
c.Assert(stats.SocketsInUse, Equals, 1)
// Refresh it, and it must be gone.
session.Refresh()
stats = mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 0)
}
func (s *S) TestNewSession(c *C) {
session, err := mgo.Dial("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
// Do a dummy operation to wait for connection.
coll := session.DB("mydb").C("mycoll")
err = coll.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Tweak safety and query settings to ensure other has copied those.
session.SetSafe(nil)
session.SetBatch(-1)
other := session.New()
defer other.Close()
session.SetSafe(&mgo.Safe{})
// Clone was copied while session was unsafe, so no errors.
otherColl := other.DB("mydb").C("mycoll")
err = otherColl.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Original session was made safe again.
err = coll.Insert(M{"_id": 1})
c.Assert(err, NotNil)
// With New(), each session has its own socket now.
stats := mgo.GetStats()
c.Assert(stats.MasterConns, Equals, 2)
c.Assert(stats.SocketsInUse, Equals, 2)
// Ensure query parameters were cloned.
err = otherColl.Insert(M{"_id": 2})
c.Assert(err, IsNil)
// Ping the database to ensure the nonce has been received already.
c.Assert(other.Ping(), IsNil)
mgo.ResetStats()
iter := otherColl.Find(M{}).Iter()
c.Assert(err, IsNil)
m := M{}
ok := iter.Next(m)
c.Assert(ok, Equals, true)
err = iter.Close()
c.Assert(err, IsNil)
// If Batch(-1) is in effect, a single document must have been received.
stats = mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 1)
}
func (s *S) TestAuthLoginCachingAcrossPoolWithLogout(c *C) {
// Now verify that logouts are properly flushed if they
// are not revalidated after leaving the pool.
session, err := mgo.Dial("localhost:40002")
c.Assert(err, IsNil)
defer session.Close()
admindb := session.DB("admin")
err = admindb.Login("root", "rapadura")
c.Assert(err, IsNil)
// Add another user to test the logout case at the same time.
mydb := session.DB("mydb")
err = mydb.AddUser("myuser", "mypass", true)
c.Assert(err, IsNil)
err = mydb.Login("myuser", "mypass")
c.Assert(err, IsNil)
// Just some data to query later.
err = session.DB("mydb").C("mycoll").Insert(M{"n": 1})
c.Assert(err, IsNil)
// Give socket back to pool.
session.Refresh()
// Brand new session, should use socket from the pool.
other := session.New()
defer other.Close()
oldStats := mgo.GetStats()
err = other.DB("mydb").Login("myuser", "mypass")
c.Assert(err, IsNil)
// Login was cached, so no ops.
newStats := mgo.GetStats()
c.Assert(newStats.SentOps, Equals, oldStats.SentOps)
// Can't write, since root has been implicitly logged out
// when the collection went into the pool, and not revalidated.
err = other.DB("mydb").C("mycoll").Insert(M{"n": 1})
c.Assert(err, ErrorMatches, "unauthorized|not authorized .*")
// But can read due to the revalidated myuser login.
result := struct{ N int }{}
err = other.DB("mydb").C("mycoll").Find(nil).One(&result)
c.Assert(err, IsNil)
c.Assert(result.N, Equals, 1)
}
func (s *S) TestAuthLoginCachingAcrossPool(c *C) {
// Logins are cached even when the conenction goes back
// into the pool.
session, err := mgo.Dial("localhost:40002")
c.Assert(err, IsNil)
defer session.Close()
admindb := session.DB("admin")
err = admindb.Login("root", "rapadura")
c.Assert(err, IsNil)
// Add another user to test the logout case at the same time.
mydb := session.DB("mydb")
err = mydb.AddUser("myuser", "mypass", false)
c.Assert(err, IsNil)
err = mydb.Login("myuser", "mypass")
c.Assert(err, IsNil)
// Logout root explicitly, to test both cases.
admindb.Logout()
// Give socket back to pool.
session.Refresh()
// Brand new session, should use socket from the pool.
other := session.New()
defer other.Close()
oldStats := mgo.GetStats()
err = other.DB("admin").Login("root", "rapadura")
c.Assert(err, IsNil)
err = other.DB("mydb").Login("myuser", "mypass")
c.Assert(err, IsNil)
// Both logins were cached, so no ops.
newStats := mgo.GetStats()
c.Assert(newStats.SentOps, Equals, oldStats.SentOps)
// And they actually worked.
err = other.DB("mydb").C("mycoll").Insert(M{"n": 1})
c.Assert(err, IsNil)
other.DB("admin").Logout()
err = other.DB("mydb").C("mycoll").Insert(M{"n": 1})
c.Assert(err, IsNil)
}
func (s *S) TestPreserveSocketCountOnSync(c *C) {
if *fast {
c.Skip("-fast")
}
session, err := mgo.Dial("localhost:40011")
c.Assert(err, IsNil)
defer session.Close()
stats := mgo.GetStats()
for stats.MasterConns+stats.SlaveConns != 3 {
stats = mgo.GetStats()
c.Log("Waiting for all connections to be established...")
time.Sleep(5e8)
}
c.Assert(stats.SocketsAlive, Equals, 3)
// Kill the master (with rs1, 'a' is always the master).
s.Stop("localhost:40011")
// Wait for the logic to run for a bit and bring it back.
go func() {
time.Sleep(5e9)
s.StartAll()
}()
// Do an action to kick the resync logic in, and also to
// wait until the cluster recognizes the server is back.
result := struct{ Ok bool }{}
err = session.Run("getLastError", &result)
c.Assert(err, IsNil)
c.Assert(result.Ok, Equals, true)
for i := 0; i != 20; i++ {
stats = mgo.GetStats()
if stats.SocketsAlive == 3 {
break
}
c.Logf("Waiting for 3 sockets alive, have %d", stats.SocketsAlive)
time.Sleep(5e8)
}
// Ensure the number of sockets is preserved after syncing.
stats = mgo.GetStats()
c.Assert(stats.SocketsAlive, Equals, 3)
c.Assert(stats.SocketsInUse, Equals, 1)
c.Assert(stats.SocketRefs, Equals, 1)
}
func (s *S) TestSetModeMonotonicAfterStrong(c *C) {
// Test that a strong session shifting to a monotonic
// one preserves the socket untouched.
session, err := mgo.Dial("localhost:40012")
c.Assert(err, IsNil)
defer session.Close()
// Insert something to force a connection to the master.
coll := session.DB("mydb").C("mycoll")
err = coll.Insert(M{"a": 1})
c.Assert(err, IsNil)
session.SetMode(mgo.Monotonic, false)
// Wait since the sync also uses sockets.
for len(session.LiveServers()) != 3 {
c.Log("Waiting for cluster sync to finish...")
time.Sleep(5e8)
}
// Master socket should still be reserved.
stats := mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 1)
// Confirm it's the master even though it's Monotonic by now.
result := M{}
cmd := session.DB("admin").C("$cmd")
err = cmd.Find(M{"ismaster": 1}).One(&result)
c.Assert(err, IsNil)
c.Assert(result["ismaster"], Equals, true)
}
func (s *S) TestAuthLoginTwiceDoesNothing(c *C) {
session, err := mgo.Dial("localhost:40002")
c.Assert(err, IsNil)
defer session.Close()
admindb := session.DB("admin")
err = admindb.Login("root", "rapadura")
c.Assert(err, IsNil)
oldStats := mgo.GetStats()
err = admindb.Login("root", "rapadura")
c.Assert(err, IsNil)
newStats := mgo.GetStats()
c.Assert(newStats.SentOps, Equals, oldStats.SentOps)
}
func (s *S) TestSocketLimit(c *C) {
if *fast {
c.Skip("-fast")
}
const socketLimit = 64
restore := mgo.HackSocketsPerServer(socketLimit)
defer restore()
session, err := mgo.Dial("localhost:40011")
c.Assert(err, IsNil)
defer session.Close()
stats := mgo.GetStats()
for stats.MasterConns+stats.SlaveConns != 3 {
stats = mgo.GetStats()
c.Log("Waiting for all connections to be established...")
time.Sleep(5e8)
}
c.Assert(stats.SocketsAlive, Equals, 3)
// Consume the whole limit for the master.
var master []*mgo.Session
for i := 0; i < socketLimit; i++ {
s := session.Copy()
defer s.Close()
err := s.Ping()
c.Assert(err, IsNil)
master = append(master, s)
}
before := time.Now()
go func() {
time.Sleep(3e9)
master[0].Refresh()
}()
// Now a single ping must block, since it would need another
// connection to the master, over the limit. Once the goroutine
// above releases its socket, it should move on.
session.Ping()
delay := time.Now().Sub(before)
c.Assert(delay > 3e9, Equals, true)
c.Assert(delay < 6e9, Equals, true)
}
func (s *S) TestSetModeMonotonic(c *C) {
// Must necessarily connect to a slave, otherwise the
// master connection will be available first.
session, err := mgo.Dial("localhost:40012")
c.Assert(err, IsNil)
defer session.Close()
session.SetMode(mgo.Monotonic, false)
c.Assert(session.Mode(), Equals, mgo.Monotonic)
result := M{}
cmd := session.DB("admin").C("$cmd")
err = cmd.Find(M{"ismaster": 1}).One(&result)
c.Assert(err, IsNil)
c.Assert(result["ismaster"], Equals, false)
coll := session.DB("mydb").C("mycoll")
err = coll.Insert(M{"a": 1})
c.Assert(err, IsNil)
result = M{}
err = cmd.Find(M{"ismaster": 1}).One(&result)
c.Assert(err, IsNil)
c.Assert(result["ismaster"], Equals, true)
// Wait since the sync also uses sockets.
for len(session.LiveServers()) != 3 {
c.Log("Waiting for cluster sync to finish...")
time.Sleep(5e8)
}
stats := mgo.GetStats()
c.Assert(stats.MasterConns, Equals, 1)
c.Assert(stats.SlaveConns, Equals, 2)
c.Assert(stats.SocketsInUse, Equals, 2)
session.SetMode(mgo.Monotonic, true)
stats = mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 0)
}
// Connect to the master of a deployment with a single server,
// run an insert, and then ensure the insert worked and that a
// single connection was established.
func (s *S) TestTopologySyncWithSingleMaster(c *C) {
// Use hostname here rather than IP, to make things trickier.
session, err := mgo.Dial("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
coll := session.DB("mydb").C("mycoll")
err = coll.Insert(M{"a": 1, "b": 2})
c.Assert(err, IsNil)
// One connection used for discovery. Master socket recycled for
// insert. Socket is reserved after insert.
stats := mgo.GetStats()
c.Assert(stats.MasterConns, Equals, 1)
c.Assert(stats.SlaveConns, Equals, 0)
c.Assert(stats.SocketsInUse, Equals, 1)
// Refresh session and socket must be released.
session.Refresh()
stats = mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 0)
}
func (s *MgoSuite) TearDownTest(c *C) {
if s.session != nil {
s.session.Close()
}
for i := 0; ; i++ {
stats := mgo.GetStats()
if stats.SocketsInUse == 0 && stats.SocketsAlive == 0 {
break
}
if i == 20 {
c.Fatal("Test left sockets in a dirty state")
}
c.Logf("Waiting for sockets to die: %d in use, %d alive", stats.SocketsInUse, stats.SocketsAlive)
time.Sleep(500 * time.Millisecond)
}
}
func (s *S) TestDirect(c *C) {
session, err := mgo.Dial("localhost:40012?connect=direct")
c.Assert(err, IsNil)
defer session.Close()
// We know that server is a slave.
session.SetMode(mgo.Monotonic, true)
result := &struct{ Host string }{}
err = session.Run("serverStatus", result)
c.Assert(err, IsNil)
c.Assert(strings.HasSuffix(result.Host, ":40012"), Equals, true)
stats := mgo.GetStats()
c.Assert(stats.SocketsAlive, Equals, 1)
c.Assert(stats.SocketsInUse, Equals, 1)
c.Assert(stats.SocketRefs, Equals, 1)
// We've got no master, so it'll timeout.
session.SetSyncTimeout(5e8 * time.Nanosecond)
coll := session.DB("mydb").C("mycoll")
err = coll.Insert(M{"test": 1})
c.Assert(err, ErrorMatches, "no reachable servers")
// Writing to the local database is okay.
coll = session.DB("local").C("mycoll")
defer coll.RemoveAll(nil)
id := bson.NewObjectId()
err = coll.Insert(M{"_id": id})
c.Assert(err, IsNil)
// Data was stored in the right server.
n, err := coll.Find(M{"_id": id}).Count()
c.Assert(err, IsNil)
c.Assert(n, Equals, 1)
// Server hasn't changed.
result.Host = ""
err = session.Run("serverStatus", result)
c.Assert(err, IsNil)
c.Assert(strings.HasSuffix(result.Host, ":40012"), Equals, true)
}
func (s *S) TestSetModeStrongAfterMonotonic(c *C) {
// Test that shifting from Monotonic to Strong while
// using a slave socket will keep the socket reserved
// until the master socket is necessary, so that no
// switch over occurs unless it's actually necessary.
// Must necessarily connect to a slave, otherwise the
// master connection will be available first.
session, err := mgo.Dial("localhost:40012")
c.Assert(err, IsNil)
defer session.Close()
session.SetMode(mgo.Monotonic, false)
// Ensure we're talking to a slave, and reserve the socket.
result := M{}
err = session.Run("ismaster", &result)
c.Assert(err, IsNil)
c.Assert(result["ismaster"], Equals, false)
// Switch to a Strong session.
session.SetMode(mgo.Strong, false)
// Wait since the sync also uses sockets.
for len(session.LiveServers()) != 3 {
c.Log("Waiting for cluster sync to finish...")
time.Sleep(5e8)
}
// Slave socket should still be reserved.
stats := mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 1)
// But any operation will switch it to the master.
result = M{}
err = session.Run("ismaster", &result)
c.Assert(err, IsNil)
c.Assert(result["ismaster"], Equals, true)
}
func (s *S) TestCloneSession(c *C) {
session, err := mgo.Dial("localhost:40001")
c.Assert(err, IsNil)
defer session.Close()
// Do a dummy operation to wait for connection.
coll := session.DB("mydb").C("mycoll")
err = coll.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Tweak safety and query settings to ensure clone is copying those.
session.SetSafe(nil)
session.SetBatch(-1)
clone := session.Clone()
defer clone.Close()
session.SetSafe(&mgo.Safe{})
// Clone was copied while session was unsafe, so no errors.
cloneColl := clone.DB("mydb").C("mycoll")
err = cloneColl.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Original session was made safe again.
err = coll.Insert(M{"_id": 1})
c.Assert(err, NotNil)
// With Clone(), same socket is shared between sessions now.
stats := mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 1)
c.Assert(stats.SocketRefs, Equals, 2)
// Refreshing one of them should let the original socket go,
// while preserving the safety settings.
clone.Refresh()
err = cloneColl.Insert(M{"_id": 1})
c.Assert(err, IsNil)
// Must have used another connection now.
stats = mgo.GetStats()
c.Assert(stats.SocketsInUse, Equals, 2)
c.Assert(stats.SocketRefs, Equals, 2)
// Ensure query parameters were cloned.
err = cloneColl.Insert(M{"_id": 2})
c.Assert(err, IsNil)
// Ping the database to ensure the nonce has been received already.
c.Assert(clone.Ping(), IsNil)
mgo.ResetStats()
iter := cloneColl.Find(M{}).Iter()
c.Assert(err, IsNil)
m := M{}
ok := iter.Next(m)
c.Assert(ok, Equals, true)
err = iter.Close()
c.Assert(err, IsNil)
// If Batch(-1) is in effect, a single document must have been received.
stats = mgo.GetStats()
c.Assert(stats.ReceivedDocs, Equals, 1)
}
func (s *S) TestGridFSSeek(c *C) {
session, err := mgo.Dial("localhost:40011")
c.Assert(err, IsNil)
defer session.Close()
db := session.DB("mydb")
gfs := db.GridFS("fs")
file, err := gfs.Create("")
c.Assert(err, IsNil)
id := file.Id()
file.SetChunkSize(5)
n, err := file.Write([]byte("abcdefghijklmnopqrstuv"))
c.Assert(err, IsNil)
c.Assert(n, Equals, 22)
err = file.Close()
c.Assert(err, IsNil)
b := make([]byte, 5)
file, err = gfs.OpenId(id)
c.Assert(err, IsNil)
o, err := file.Seek(3, os.SEEK_SET)
c.Assert(err, IsNil)
c.Assert(o, Equals, int64(3))
_, err = file.Read(b)
c.Assert(err, IsNil)
c.Assert(b, DeepEquals, []byte("defgh"))
o, err = file.Seek(5, os.SEEK_CUR)
c.Assert(err, IsNil)
c.Assert(o, Equals, int64(13))
_, err = file.Read(b)
c.Assert(err, IsNil)
c.Assert(b, DeepEquals, []byte("nopqr"))
o, err = file.Seek(-10, os.SEEK_END)
c.Assert(err, IsNil)
c.Assert(o, Equals, int64(12))
_, err = file.Read(b)
c.Assert(err, IsNil)
c.Assert(b, DeepEquals, []byte("mnopq"))
o, err = file.Seek(8, os.SEEK_SET)
c.Assert(err, IsNil)
c.Assert(o, Equals, int64(8))
_, err = file.Read(b)
c.Assert(err, IsNil)
c.Assert(b, DeepEquals, []byte("ijklm"))
// Trivial seek forward within same chunk. Already
// got the data, shouldn't touch the database.
sent := mgo.GetStats().SentOps
o, err = file.Seek(1, os.SEEK_CUR)
c.Assert(err, IsNil)
c.Assert(o, Equals, int64(14))
c.Assert(mgo.GetStats().SentOps, Equals, sent)
_, err = file.Read(b)
c.Assert(err, IsNil)
c.Assert(b, DeepEquals, []byte("opqrs"))
// Try seeking past end of file.
file.Seek(3, os.SEEK_SET)
o, err = file.Seek(23, os.SEEK_SET)
c.Assert(err, ErrorMatches, "Seek past end of file")
c.Assert(o, Equals, int64(3))
}