func (s *S) TestNewObjectId(c *C) {
// Generate 10 ids
ids := make([]bson.ObjectId, 10)
for i := 0; i < 10; i++ {
ids[i] = bson.NewObjectId()
}
for i := 1; i < 10; i++ {
prevId := ids[i-1]
id := ids[i]
// Test for uniqueness among all other 9 generated ids
for j, tid := range ids {
if j != i {
c.Assert(id, Not(Equals), tid, Commentf("Generated ObjectId is not unique"))
}
}
// Check that timestamp was incremented and is within 30 seconds of the previous one
secs := id.Time().Sub(prevId.Time()).Seconds()
c.Assert((secs >= 0 && secs <= 30), Equals, true, Commentf("Wrong timestamp in generated ObjectId"))
// Check that machine ids are the same
c.Assert(id.Machine(), DeepEquals, prevId.Machine())
// Check that pids are the same
c.Assert(id.Pid(), Equals, prevId.Pid())
// Test for proper increment
delta := int(id.Counter() - prevId.Counter())
c.Assert(delta, Equals, 1, Commentf("Wrong increment in generated ObjectId"))
}
}
// Run creates a new transaction with ops and runs it immediately.
// The id parameter specifies the transaction id, and may be written
// down ahead of time to later verify the success of the change and
// resume it, when the procedure is interrupted for any reason. If
// empty, a random id will be generated.
// The info parameter, if not nil, is included under the "i"
// field of the transaction document.
//
// Operations across documents are not atomically applied, but are
// guaranteed to be eventually all applied in the order provided or
// all aborted, as long as the affected documents are only modified
// through transactions. If documents are simultaneously modified
// by transactions and out of transactions the behavior is undefined.
//
// If Run returns no errors, all operations were applied successfully.
// If it returns ErrAborted, one or more operations can't be applied
// and the transaction was entirely aborted with no changes performed.
// Otherwise, if the transaction is interrupted while running for any
// reason, it may be resumed explicitly or by attempting to apply
// another transaction on any of the documents targeted by ops, as
// long as the interruption was made after the transaction document
// itself was inserted. Run Resume with the obtained transaction id
// to confirm whether the transaction was applied or not.
//
// Any number of transactions may be run concurrently, with one
// runner or many.
func (r *Runner) Run(ops []Op, id bson.ObjectId, info interface{}) (err error) {
const efmt = "error in transaction op %d: %s"
for i := range ops {
op := &ops[i]
if op.C == "" || op.Id == nil {
return fmt.Errorf(efmt, i, "C or Id missing")
}
changes := 0
if op.Insert != nil {
changes++
}
if op.Update != nil {
changes++
}
if op.Remove {
changes++
}
if changes > 1 {
return fmt.Errorf(efmt, i, "more than one of Insert/Update/Remove set")
}
if changes == 0 && op.Assert == nil {
return fmt.Errorf(efmt, i, "none of Assert/Insert/Update/Remove set")
}
}
if id == "" {
id = bson.NewObjectId()
}
// Insert transaction sooner rather than later, to stay on the safer side.
t := transaction{
Id: id,
Ops: ops,
State: tpreparing,
Info: info,
}
if err = r.tc.Insert(&t); err != nil {
return err
}
if err = flush(r, &t); err != nil {
return err
}
if t.State == taborted {
return ErrAborted
} else if t.State != tapplied {
panic(fmt.Errorf("invalid state for %s after flush: %q", &t, t.State))
}
return nil
}
func (s *S) TestInfo(c *C) {
ops := []txn.Op{{
C: "accounts",
Id: 0,
Assert: txn.DocMissing,
}}
id := bson.NewObjectId()
err := s.runner.Run(ops, id, M{"n": 42})
c.Assert(err, IsNil)
var t struct{ I struct{ N int } }
err = s.tc.FindId(id).One(&t)
c.Assert(err, IsNil)
c.Assert(t.I.N, Equals, 42)
}
func (self *projectServer) Create(ctx context.Context, p *msg.Project) (*msg.Project, error) {
res, err := database.NewProjectFromMsg(p)
if err != nil {
return nil, err
}
if !res.Id.Valid() {
res.Id = bson.NewObjectId()
}
err = self.core.Db.Create("Projects", res)
return res.ToMessage(), err
}
func (self *Server) createProject(w http.ResponseWriter, r *http.Request) {
var project database.Project
err := self.read(r, &project)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
}
project.Id = bson.NewObjectId()
err = self.core.Db.Create(database.ProjectsCol, &project)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
}
self.respond(w, &project)
}
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) TestQueueStashing(c *C) {
txn.SetChaos(txn.Chaos{
KillChance: 1,
Breakpoint: "set-applying",
})
opses := [][]txn.Op{{{
C: "accounts",
Id: 0,
Insert: M{"balance": 100},
}}, {{
C: "accounts",
Id: 0,
Remove: true,
}}, {{
C: "accounts",
Id: 0,
Insert: M{"balance": 200},
}}, {{
C: "accounts",
Id: 0,
Update: M{"$inc": M{"balance": 100}},
}}}
var last bson.ObjectId
for _, ops := range opses {
last = bson.NewObjectId()
err := s.runner.Run(ops, last, nil)
c.Assert(err, Equals, txn.ErrChaos)
}
txn.SetChaos(txn.Chaos{})
err := s.runner.Resume(last)
c.Assert(err, IsNil)
var account Account
err = s.accounts.FindId(0).One(&account)
c.Assert(err, IsNil)
c.Assert(account.Balance, Equals, 300)
}
func (self *Resources) Create(options *ResourceCreateOptions) (*database.Resource, error) {
self.lock.RLock()
defer self.lock.RUnlock()
resource := options.Resource
resType, ok := self.resourceTypes[strings.ToLower(resource.Type)]
if !ok {
return nil, fmt.Errorf("could not find resource type: %s", resource.Type)
}
//var m types.Message
_, err := resType.Create(struct{}{}, resource)
if err != nil {
return nil, err
}
resource.Id = bson.NewObjectId()
resource.ProjectId = options.Project.Id
/*res := database.Resource{
Id: bson.NewObjectId(),
Name: options.Name,
ProjectId: options.Project.Id,
Type: options.Type,
Fields: *m,
}*/
err = self.core.Db.Create(database.ResourcesCol, resource)
if err == nil {
self.publish(resource)
}
return resource, err
}
func (s *S) TestPurgeMissingPipelineSizeLimit(c *C) {
// This test ensures that PurgeMissing can handle very large
// txn-queue fields. Previous iterations of PurgeMissing would
// trigger a 16MB aggregation pipeline result size limit when run
// against a documents or stashes with large numbers of txn-queue
// entries. PurgeMissing now no longer uses aggregation pipelines
// to work around this limit.
// The pipeline result size limitation was removed from MongoDB in 2.6 so
// this test is only run for older MongoDB version.
build, err := s.session.BuildInfo()
c.Assert(err, IsNil)
if build.VersionAtLeast(2, 6) {
c.Skip("This tests a problem that can only happen with MongoDB < 2.6 ")
}
// Insert a single document to work with.
err = s.accounts.Insert(M{"_id": 0, "balance": 100})
c.Assert(err, IsNil)
ops := []txn.Op{{
C: "accounts",
Id: 0,
Update: M{"$inc": M{"balance": 100}},
}}
// Generate one successful transaction.
good := bson.NewObjectId()
c.Logf("---- Running ops under transaction %q", good.Hex())
err = s.runner.Run(ops, good, nil)
c.Assert(err, IsNil)
// Generate another transaction which which will go missing.
missing := bson.NewObjectId()
c.Logf("---- Running ops under transaction %q (which will go missing)", missing.Hex())
err = s.runner.Run(ops, missing, nil)
c.Assert(err, IsNil)
err = s.tc.RemoveId(missing)
c.Assert(err, IsNil)
// Generate a txn-queue on the test document that's large enough
// that it used to cause PurgeMissing to exceed MongoDB's pipeline
// result 16MB size limit (MongoDB 2.4 and older only).
//
// The contents of the txn-queue field doesn't matter, only that
// it's big enough to trigger the size limit. The required size
// can also be achieved by using multiple documents as long as the
// cumulative size of all the txn-queue fields exceeds the
// pipeline limit. A single document is easier to work with for
// this test however.
//
// The txn id of the successful transaction is used fill the
// txn-queue because this takes advantage of a short circuit in
// PurgeMissing, dramatically speeding up the test run time.
const fakeQueueLen = 250000
fakeTxnQueue := make([]string, fakeQueueLen)
token := good.Hex() + "_12345678" // txn id + nonce
for i := 0; i < fakeQueueLen; i++ {
fakeTxnQueue[i] = token
}
err = s.accounts.UpdateId(0, bson.M{
"$set": bson.M{"txn-queue": fakeTxnQueue},
})
c.Assert(err, IsNil)
// PurgeMissing could hit the same pipeline result size limit when
// processing the txn-queue fields of stash documents so insert
// the large txn-queue there too to ensure that no longer happens.
err = s.sc.Insert(
bson.D{{"c", "accounts"}, {"id", 0}},
bson.M{"txn-queue": fakeTxnQueue},
)
c.Assert(err, IsNil)
c.Logf("---- Purging missing transactions")
err = s.runner.PurgeMissing("accounts")
c.Assert(err, IsNil)
}
func (s *S) TestPurgeMissing(c *C) {
txn.SetChaos(txn.Chaos{
KillChance: 1,
Breakpoint: "set-applying",
})
err := s.accounts.Insert(M{"_id": 0, "balance": 100})
c.Assert(err, IsNil)
err = s.accounts.Insert(M{"_id": 1, "balance": 100})
c.Assert(err, IsNil)
ops1 := []txn.Op{{
C: "accounts",
Id: 3,
Insert: M{"balance": 100},
}}
ops2 := []txn.Op{{
C: "accounts",
Id: 0,
Remove: true,
}, {
C: "accounts",
Id: 1,
Update: M{"$inc": M{"balance": 100}},
}, {
C: "accounts",
Id: 2,
Insert: M{"balance": 100},
}}
first := bson.NewObjectId()
c.Logf("---- Running ops1 under transaction %q, to be canceled by chaos", first.Hex())
err = s.runner.Run(ops1, first, nil)
c.Assert(err, Equals, txn.ErrChaos)
last := bson.NewObjectId()
c.Logf("---- Running ops2 under transaction %q, to be canceled by chaos", last.Hex())
err = s.runner.Run(ops2, last, nil)
c.Assert(err, Equals, txn.ErrChaos)
c.Logf("---- Removing transaction %q", last.Hex())
err = s.tc.RemoveId(last)
c.Assert(err, IsNil)
c.Logf("---- Disabling chaos and attempting to resume all")
txn.SetChaos(txn.Chaos{})
err = s.runner.ResumeAll()
c.Assert(err, IsNil)
again := bson.NewObjectId()
c.Logf("---- Running ops2 again under transaction %q, to fail for missing transaction", again.Hex())
err = s.runner.Run(ops2, again, nil)
c.Assert(err, ErrorMatches, "cannot find transaction .*")
c.Logf("---- Purging missing transactions")
err = s.runner.PurgeMissing("accounts")
c.Assert(err, IsNil)
c.Logf("---- Resuming pending transactions")
err = s.runner.ResumeAll()
c.Assert(err, IsNil)
expect := []struct{ Id, Balance int }{
{0, -1},
{1, 200},
{2, 100},
{3, 100},
}
var got Account
for _, want := range expect {
err = s.accounts.FindId(want.Id).One(&got)
if want.Balance == -1 {
if err != mgo.ErrNotFound {
c.Errorf("Account %d should not exist, find got err=%#v", err)
}
} else if err != nil {
c.Errorf("Account %d should have balance of %d, but wasn't found", want.Id, want.Balance)
} else if got.Balance != want.Balance {
c.Errorf("Account %d should have balance of %d, got %d", want.Id, want.Balance, got.Balance)
}
}
}
func (s *S) TestChangeLog(c *C) {
chglog := s.db.C("chglog")
s.runner.ChangeLog(chglog)
ops := []txn.Op{{
C: "debts",
Id: 0,
Assert: txn.DocMissing,
}, {
C: "accounts",
Id: 0,
Insert: M{"balance": 300},
}, {
C: "accounts",
Id: 1,
Insert: M{"balance": 300},
}, {
C: "people",
Id: "joe",
Insert: M{"accounts": []int64{0, 1}},
}}
id := bson.NewObjectId()
err := s.runner.Run(ops, id, nil)
c.Assert(err, IsNil)
type IdList []interface{}
type Log struct {
Docs IdList "d"
Revnos []int64 "r"
}
var m map[string]*Log
err = chglog.FindId(id).One(&m)
c.Assert(err, IsNil)
c.Assert(m["accounts"], DeepEquals, &Log{IdList{0, 1}, []int64{2, 2}})
c.Assert(m["people"], DeepEquals, &Log{IdList{"joe"}, []int64{2}})
c.Assert(m["debts"], IsNil)
ops = []txn.Op{{
C: "accounts",
Id: 0,
Update: M{"$inc": M{"balance": 100}},
}, {
C: "accounts",
Id: 1,
Update: M{"$inc": M{"balance": 100}},
}}
id = bson.NewObjectId()
err = s.runner.Run(ops, id, nil)
c.Assert(err, IsNil)
m = nil
err = chglog.FindId(id).One(&m)
c.Assert(err, IsNil)
c.Assert(m["accounts"], DeepEquals, &Log{IdList{0, 1}, []int64{3, 3}})
c.Assert(m["people"], IsNil)
ops = []txn.Op{{
C: "accounts",
Id: 0,
Remove: true,
}, {
C: "people",
Id: "joe",
Remove: true,
}}
id = bson.NewObjectId()
err = s.runner.Run(ops, id, nil)
c.Assert(err, IsNil)
m = nil
err = chglog.FindId(id).One(&m)
c.Assert(err, IsNil)
c.Assert(m["accounts"], DeepEquals, &Log{IdList{0}, []int64{-4}})
c.Assert(m["people"], DeepEquals, &Log{IdList{"joe"}, []int64{-3}})
}