func newState(session *mgo.Session, info *Info) (*State, error) {
db := session.DB("juju")
pdb := session.DB("presence")
if info.Tag != "" {
if err := db.Login(info.Tag, info.Password); err != nil {
return nil, maybeUnauthorized(err, fmt.Sprintf("cannot log in to juju database as %q", info.Tag))
}
if err := pdb.Login(info.Tag, info.Password); err != nil {
return nil, maybeUnauthorized(err, fmt.Sprintf("cannot log in to presence database as %q", info.Tag))
}
} else if info.Password != "" {
admin := session.DB("admin")
if err := admin.Login("admin", info.Password); err != nil {
return nil, maybeUnauthorized(err, "cannot log in to admin database")
}
}
st := &State{
info: info,
db: db,
environments: db.C("environments"),
charms: db.C("charms"),
machines: db.C("machines"),
containerRefs: db.C("containerRefs"),
instanceData: db.C("instanceData"),
relations: db.C("relations"),
relationScopes: db.C("relationscopes"),
services: db.C("services"),
minUnits: db.C("minunits"),
settings: db.C("settings"),
settingsrefs: db.C("settingsrefs"),
constraints: db.C("constraints"),
units: db.C("units"),
users: db.C("users"),
presence: pdb.C("presence"),
cleanups: db.C("cleanups"),
annotations: db.C("annotations"),
statuses: db.C("statuses"),
}
log := db.C("txns.log")
logInfo := mgo.CollectionInfo{Capped: true, MaxBytes: logSize}
// The lack of error code for this error was reported upstream:
// https://jira.klmongodb.org/browse/SERVER-6992
err := log.Create(&logInfo)
if err != nil && err.Error() != "collection already exists" {
return nil, maybeUnauthorized(err, "cannot create log collection")
}
st.runner = txn.NewRunner(db.C("txns"))
st.runner.ChangeLog(db.C("txns.log"))
st.watcher = watcher.New(db.C("txns.log"))
st.pwatcher = presence.NewWatcher(pdb.C("presence"))
for _, item := range indexes {
index := mgo.Index{Key: item.key}
if err := db.C(item.collection).EnsureIndex(index); err != nil {
return nil, fmt.Errorf("cannot create database index: %v", err)
}
}
st.transactionHooks = make(chan ([]transactionHook), 1)
st.transactionHooks <- nil
return st, nil
}
func (s *txnSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.MgoSuite.SetUpTest(c)
db := s.Session.DB("juju")
s.collection = db.C("test")
s.txnRunner = statetxn.NewRunner(txn.NewRunner(s.collection))
}
func (s *managedStorageSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.MgoSuite.SetUpTest(c)
s.db = s.Session.DB("juju")
s.txnRunner = statetxn.NewRunner(txn.NewRunner(s.db.C("txns")))
s.resourceStorage = storage.NewGridFS("storage", "test", s.Session)
s.managedStorage = storage.NewManagedStorage(s.db, s.txnRunner, s.resourceStorage)
}
func (s *resourceCatalogSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.MgoSuite.SetUpTest(c)
db := s.Session.DB("juju")
s.collection = db.C("storedResources")
s.txnRunner = statetxn.NewRunner(txn.NewRunner(db.C("resourceTxns")))
s.rCatalog = storage.NewResourceCatalog(s.collection, s.txnRunner)
}
func (this *Article) Save() error {
this.Id = bson.NewObjectId()
if len(this.Parent) == 0 {
if err := save(articleColl, this, true); err != nil {
return errors.NewError(errors.DbError, err.Error())
}
return nil
}
if !bson.IsObjectIdHex(this.Parent) {
return errors.NewError(errors.InvalidMsgError)
}
update := bson.M{
"$push": bson.M{
"reviews": this.Id.Hex(),
},
"$inc": bson.M{
"review_count": 1,
},
}
if this.Type == ArticleCoach {
update = bson.M{
"$addToSet": bson.M{
"coaches": this.Author,
},
"$inc": bson.M{
"coach_review_count": 1,
},
}
}
f := func(c *mgo.Collection) error {
runner := txn.NewRunner(c)
ops := []txn.Op{
{
C: articleColl,
Id: this.Id,
Assert: txn.DocMissing,
Insert: this,
},
{
C: articleColl,
Id: bson.ObjectIdHex(this.Parent),
Assert: txn.DocExists,
Update: update,
},
}
return runner.Run(ops, bson.NewObjectId(), nil)
}
if err := withCollection("comment_tx", &mgo.Safe{}, f); err != nil {
log.Println(err)
return errors.NewError(errors.DbError, err.Error())
}
return nil
}
func (this *Article) Remove() error {
find, err := this.findOne(bson.M{"author": this.Author, "_id": this.Id})
if !find {
return err
}
if len(this.Parent) == 0 {
if err := removeId(articleColl, this.Id, true); err != nil {
if e, ok := err.(*mgo.LastError); ok {
return errors.NewError(errors.DbError, e.Error())
}
}
return nil
}
update := bson.M{
"$pull": bson.M{
"reviews": this.Id.Hex(),
},
"$inc": bson.M{
"review_count": -1,
},
}
if this.Type == ArticleCoach {
update = bson.M{
"$inc": bson.M{
"coach_review_count": -1,
},
}
}
f := func(c *mgo.Collection) error {
runner := txn.NewRunner(c)
ops := []txn.Op{
{
C: articleColl,
Id: this.Id,
Remove: true,
},
{
C: articleColl,
Id: bson.ObjectIdHex(this.Parent),
Update: update,
},
}
return runner.Run(ops, bson.NewObjectId(), nil)
}
if err := withCollection("comment_tx", &mgo.Safe{}, f); err != nil {
log.Println(err)
return errors.NewError(errors.DbError, err.Error())
}
return nil
}
//NewContext returns a new context for the given request.
func NewContext(req *http.Request) Context {
if Config.DB == nil {
panic("Didn't set httputil.Config.DB before creating contexts")
}
db := Config.DB.Session.Clone().DB(Config.DB.Name)
return Context{
DB: db,
R: txn.NewRunner(db.C(Config.Txn)),
}
}
func (s *S) SetUpTest(c *C) {
txn.SetChaos(txn.Chaos{})
txn.SetLogger(c)
txn.SetDebug(true)
s.MgoSuite.SetUpTest(c)
s.db = s.session.DB("test")
s.tc = s.db.C("tc")
s.sc = s.db.C("tc.stash")
s.accounts = s.db.C("accounts")
s.runner = txn.NewRunner(s.tc)
}
func (s *benchmarkSuite) BenchmarkManagedStorageCreate(c *gc.C) {
db := s.Session.DB("a-database")
txnRunner := jujuTxn.NewRunner(txn.NewRunner(db.C("txns")))
rstore := storage.NewGridFS(db.Name, "prefix", s.Session)
store := storage.NewManagedStorage(db, txnRunner, rstore)
c.ResetTimer()
const fileSize = 30 * 1024
for i := 0; i < c.N; i++ {
src := newDataSource(int64(i), fileSize)
err := store.PutForEnvironment("env-uuid", fmt.Sprintf("file%d", i), src, fileSize)
c.Assert(err, gc.IsNil)
}
}
func (s *WatcherSuite) SetUpTest(c *C) {
s.LoggingSuite.SetUpTest(c)
s.MgoSuite.SetUpTest(c)
db := s.MgoSuite.Session.DB("juju")
s.log = db.C("txnlog")
s.log.Create(&mgo.CollectionInfo{
Capped: true,
MaxBytes: 1000000,
})
s.stash = db.C("txn.stash")
s.runner = txn.NewRunner(db.C("txn"))
s.runner.ChangeLog(s.log)
s.w = watcher.New(s.log)
s.ch = make(chan watcher.Change)
}
func simulate(c *C, params params) {
seed := *seed
if seed == 0 {
seed = time.Now().UnixNano()
}
rand.Seed(seed)
c.Logf("Seed: %v", seed)
txn.SetChaos(txn.Chaos{
KillChance: params.killChance,
SlowdownChance: params.slowdownChance,
Slowdown: params.slowdown,
})
defer txn.SetChaos(txn.Chaos{})
session, err := mgo.Dial(mgoaddr)
c.Assert(err, IsNil)
defer session.Close()
db := session.DB("test")
tc := db.C("tc")
runner := txn.NewRunner(tc)
tclog := db.C("tc.log")
if params.changelog {
info := mgo.CollectionInfo{
Capped: true,
MaxBytes: 1000000,
}
err := tclog.Create(&info)
c.Assert(err, IsNil)
runner.ChangeLog(tclog)
}
accounts := db.C("accounts")
for i := 0; i < params.accounts; i++ {
err := accounts.Insert(M{"_id": i, "balance": 300})
c.Assert(err, IsNil)
}
var stop time.Time
if params.changes <= 0 {
stop = time.Now().Add(*duration)
}
max := params.accounts
if params.reinsertCopy || params.reinsertZeroed {
max = int(float64(params.accounts) * 1.5)
}
changes := make(chan balanceChange, 1024)
//session.SetMode(mgo.Eventual, true)
for i := 0; i < params.workers; i++ {
go func() {
n := 0
for {
if n > 0 && n == params.changes {
break
}
if !stop.IsZero() && time.Now().After(stop) {
break
}
change := balanceChange{
id: bson.NewObjectId(),
origin: rand.Intn(max),
target: rand.Intn(max),
amount: 100,
}
var old Account
var oldExists bool
if params.reinsertCopy || params.reinsertZeroed {
if err := accounts.FindId(change.origin).One(&old); err != mgo.ErrNotFound {
c.Check(err, IsNil)
change.amount = old.Balance
oldExists = true
}
}
var ops []txn.Op
switch {
case params.reinsertCopy && oldExists:
ops = []txn.Op{{
C: "accounts",
Id: change.origin,
Assert: M{"balance": change.amount},
Remove: true,
}, {
C: "accounts",
Id: change.target,
Assert: txn.DocMissing,
Insert: M{"balance": change.amount},
}}
case params.reinsertZeroed && oldExists:
ops = []txn.Op{{
C: "accounts",
Id: change.target,
Assert: txn.DocMissing,
Insert: M{"balance": 0},
}, {
C: "accounts",
Id: change.origin,
Assert: M{"balance": change.amount},
Remove: true,
}, {
C: "accounts",
Id: change.target,
Assert: txn.DocExists,
Update: M{"$inc": M{"balance": change.amount}},
}}
case params.changeHalf:
ops = []txn.Op{{
C: "accounts",
Id: change.origin,
Assert: M{"balance": M{"$gte": change.amount}},
Update: M{"$inc": M{"balance": -change.amount / 2}},
}, {
C: "accounts",
Id: change.target,
Assert: txn.DocExists,
Update: M{"$inc": M{"balance": change.amount / 2}},
}, {
C: "accounts",
Id: change.origin,
Update: M{"$inc": M{"balance": -change.amount / 2}},
}, {
C: "accounts",
Id: change.target,
Update: M{"$inc": M{"balance": change.amount / 2}},
}}
default:
ops = []txn.Op{{
C: "accounts",
Id: change.origin,
Assert: M{"balance": M{"$gte": change.amount}},
Update: M{"$inc": M{"balance": -change.amount}},
}, {
C: "accounts",
Id: change.target,
Assert: txn.DocExists,
Update: M{"$inc": M{"balance": change.amount}},
}}
}
err = runner.Run(ops, change.id, nil)
if err != nil && err != txn.ErrAborted && err != txn.ErrChaos {
c.Check(err, IsNil)
}
n++
changes <- change
}
changes <- balanceChange{}
}()
}
alive := params.workers
changeLog := make([]balanceChange, 0, 1024)
for alive > 0 {
change := <-changes
if change.id == "" {
alive--
} else {
changeLog = append(changeLog, change)
}
}
c.Check(len(changeLog), Not(Equals), 0, Commentf("No operations were even attempted."))
txn.SetChaos(txn.Chaos{})
err = runner.ResumeAll()
c.Assert(err, IsNil)
n, err := accounts.Count()
c.Check(err, IsNil)
c.Check(n, Equals, params.accounts, Commentf("Number of accounts has changed."))
n, err = accounts.Find(M{"balance": M{"$lt": 0}}).Count()
c.Check(err, IsNil)
c.Check(n, Equals, 0, Commentf("There are %d accounts with negative balance.", n))
globalBalance := 0
iter := accounts.Find(nil).Iter()
account := Account{}
for iter.Next(&account) {
globalBalance += account.Balance
}
c.Check(iter.Close(), IsNil)
c.Check(globalBalance, Equals, params.accounts*300, Commentf("Total amount of money should be constant."))
// Compute and verify the exact final state of all accounts.
balance := make(map[int]int)
for i := 0; i < params.accounts; i++ {
balance[i] += 300
}
var applied, aborted int
for _, change := range changeLog {
err := runner.Resume(change.id)
if err == txn.ErrAborted {
aborted++
continue
} else if err != nil {
c.Fatalf("resuming %s failed: %v", change.id, err)
}
balance[change.origin] -= change.amount
balance[change.target] += change.amount
applied++
}
iter = accounts.Find(nil).Iter()
for iter.Next(&account) {
c.Assert(account.Balance, Equals, balance[account.Id])
}
c.Check(iter.Close(), IsNil)
c.Logf("Total transactions: %d (%d applied, %d aborted)", len(changeLog), applied, aborted)
if params.changelog {
n, err := tclog.Count()
c.Assert(err, IsNil)
// Check if the capped collection is full.
dummy := make([]byte, 1024)
tclog.Insert(M{"_id": bson.NewObjectId(), "dummy": dummy})
m, err := tclog.Count()
c.Assert(err, IsNil)
if m == n+1 {
// Wasn't full, so it must have seen it all.
c.Assert(err, IsNil)
c.Assert(n, Equals, applied)
}
}
}
func newState(session *mgo.Session, info *Info, policy Policy) (*State, error) {
db := session.DB("juju")
pdb := session.DB("presence")
admin := session.DB("admin")
if info.Tag != "" {
if err := db.Login(info.Tag, info.Password); err != nil {
return nil, maybeUnauthorized(err, fmt.Sprintf("cannot log in to juju database as %q", info.Tag))
}
if err := pdb.Login(info.Tag, info.Password); err != nil {
return nil, maybeUnauthorized(err, fmt.Sprintf("cannot log in to presence database as %q", info.Tag))
}
if err := admin.Login(info.Tag, info.Password); err != nil {
return nil, maybeUnauthorized(err, fmt.Sprintf("cannot log in to admin database as %q", info.Tag))
}
} else if info.Password != "" {
if err := admin.Login(AdminUser, info.Password); err != nil {
return nil, maybeUnauthorized(err, "cannot log in to admin database")
}
}
st := &State{
info: info,
policy: policy,
db: db,
environments: db.C("environments"),
charms: db.C("charms"),
machines: db.C("machines"),
containerRefs: db.C("containerRefs"),
instanceData: db.C("instanceData"),
relations: db.C("relations"),
relationScopes: db.C("relationscopes"),
services: db.C("services"),
requestedNetworks: db.C("requestednetworks"),
networks: db.C("networks"),
networkInterfaces: db.C("networkinterfaces"),
minUnits: db.C("minunits"),
settings: db.C("settings"),
settingsrefs: db.C("settingsrefs"),
constraints: db.C("constraints"),
units: db.C("units"),
actions: db.C("actions"),
actionresults: db.C("actionresults"),
users: db.C("users"),
presence: pdb.C("presence"),
cleanups: db.C("cleanups"),
annotations: db.C("annotations"),
statuses: db.C("statuses"),
stateServers: db.C("stateServers"),
}
log := db.C("txns.log")
logInfo := mgo.CollectionInfo{Capped: true, MaxBytes: logSize}
// The lack of error code for this error was reported upstream:
// https://jira.klmongodb.org/browse/SERVER-6992
err := log.Create(&logInfo)
if err != nil && err.Error() != "collection already exists" {
return nil, maybeUnauthorized(err, "cannot create log collection")
}
mgoRunner := txn.NewRunner(db.C("txns"))
mgoRunner.ChangeLog(db.C("txns.log"))
st.transactionRunner = statetxn.NewRunner(mgoRunner)
st.watcher = watcher.New(db.C("txns.log"))
st.pwatcher = presence.NewWatcher(pdb.C("presence"))
for _, item := range indexes {
index := mgo.Index{Key: item.key, Unique: item.unique}
if err := db.C(item.collection).EnsureIndex(index); err != nil {
return nil, fmt.Errorf("cannot create database index: %v", err)
}
}
// TODO(rog) delete this when we can assume there are no
// pre-1.18 environments running.
if err := st.createStateServersDoc(); err != nil {
return nil, fmt.Errorf("cannot create state servers document: %v", err)
}
if err := st.createAPIAddressesDoc(); err != nil {
return nil, fmt.Errorf("cannot create API addresses document: %v", err)
}
if err := st.createStateServingInfoDoc(); err != nil {
return nil, fmt.Errorf("cannot create state serving info document: %v", err)
}
return st, nil
}
