// DumpColl dumps the contents of a mongo database collection.
func DumpColl(db *mgo.Database, collName string) {
if off {
return
}
coll, closer := mongo.CollectionFromName(db, collName)
defer closer()
var results []interface{}
err := coll.Find(nil).All(&results)
if err != nil {
panic(err)
}
called(2, collName)
if len(results) == 0 {
fmt.Println("no results found")
return
}
for i, r := range results {
output, err := json.MarshalIndent(r, "", " ")
if err != nil {
fmt.Print(err.Error())
}
fmt.Printf("Doc %d (%T): %s\n", i, r, output)
fmt.Println("")
}
fmt.Println("")
}
func isNotDead(db *mgo.Database, collName string, id interface{}) (bool, error) {
coll, closer := mongo.CollectionFromName(db, collName)
defer closer()
n, err := coll.Find(bson.D{{"_id", id}, {"life", bson.D{{"$ne", Dead}}}}).Count()
return n == 1, err
}
// GetCollection is part of the Database interface.
func (db *database) GetCollection(name string) (collection mongo.Collection, closer SessionCloser) {
info, found := db.schema[name]
if !found {
logger.Errorf("using unknown collection %q", name)
}
// Copy session if necessary.
if db.ownSession {
collection = mongo.WrapCollection(db.raw.C(name))
closer = dontCloseAnything
} else {
collection, closer = mongo.CollectionFromName(db.raw, name)
}
// Apply model filtering.
if !info.global {
collection = &modelStateCollection{
WriteCollection: collection.Writeable(),
modelUUID: db.modelUUID,
}
}
// Prevent layer-breaking.
if !info.rawAccess {
// TODO(fwereade): it would be nice to tweak the mongo.Collection
// interface a bit to drop Writeable in this situation, but it's
// not convenient yet.
}
return collection, closer
}
func (s *imageStorage) imageMetadataDoc(envUUID, kind, series, arch string) (imageMetadataDoc, error) {
var doc imageMetadataDoc
id := fmt.Sprintf("%s-%s-%s-%s", envUUID, kind, series, arch)
coll, closer := mongo.CollectionFromName(s.metadataCollection.Database, imagemetadataC)
defer closer()
err := coll.FindId(id).One(&doc)
if err == mgo.ErrNotFound {
return doc, errors.NotFoundf("%v image metadata", id)
} else if err != nil {
return doc, err
}
return doc, nil
}
func (s *cloudImageMetadataSuite) TestSaveAndFindAndDeleteMetadata(c *gc.C) {
metadata, err := s.client.List("", "", nil, nil, "", "")
c.Assert(err, gc.ErrorMatches, "matching cloud image metadata not found")
c.Assert(metadata, gc.HasLen, 0)
// check db too
conn := s.State.MongoSession()
coll, closer := mongo.CollectionFromName(conn.DB("juju"), "cloudimagemetadata")
defer closer()
before, err := coll.Count()
c.Assert(err, jc.ErrorIsNil)
c.Assert(before == 0, jc.IsTrue)
imageId := "1"
m := params.CloudImageMetadata{
Source: "custom",
Stream: "stream",
Region: "region",
Series: "trusty",
Arch: "arch",
VirtType: "virtType",
RootStorageType: "rootStorageType",
ImageId: imageId,
}
err = s.client.Save([]params.CloudImageMetadata{m})
c.Assert(err, jc.ErrorIsNil)
added, err := s.client.List("", "", nil, nil, "", "")
c.Assert(err, jc.ErrorIsNil)
// m.Version would be deduced from m.Series
m.Version = "14.04"
c.Assert(added, jc.DeepEquals, []params.CloudImageMetadata{m})
// make sure it's in db too
after, err := coll.Count()
c.Assert(err, jc.ErrorIsNil)
c.Assert(after == 1, jc.IsTrue)
err = s.client.Delete(imageId)
c.Assert(err, jc.ErrorIsNil)
// make sure it's no longer in db too
afterDelete, err := coll.Count()
c.Assert(err, jc.ErrorIsNil)
c.Assert(afterDelete, gc.Equals, 0)
}
func (s *imageStorage) listImageMetadataDocs(envUUID, kind, series, arch string) ([]imageMetadataDoc, error) {
coll, closer := mongo.CollectionFromName(s.metadataCollection.Database, imagemetadataC)
defer closer()
imageDocs := []imageMetadataDoc{}
filter := bson.D{{"envuuid", envUUID}}
if kind != "" {
filter = append(filter, bson.DocElem{"kind", kind})
}
if series != "" {
filter = append(filter, bson.DocElem{"series", series})
}
if arch != "" {
filter = append(filter, bson.DocElem{"arch", arch})
}
err := coll.Find(filter).All(&imageDocs)
return imageDocs, err
}
func (s *binaryStorageSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.mongo = &gitjujutesting.MgoInstance{}
s.mongo.Start(nil)
var err error
var closer func()
s.session, err = s.mongo.Dial()
c.Assert(err, jc.ErrorIsNil)
rs := blobstore.NewGridFS("blobstore", "blobstore", s.session)
catalogue := s.session.DB("catalogue")
s.managedStorage = blobstore.NewManagedStorage(catalogue, rs)
s.metadataCollection, closer = mongo.CollectionFromName(catalogue, "binarymetadata")
s.AddCleanup(func(*gc.C) { closer() })
s.txnRunner = jujutxn.NewRunner(jujutxn.RunnerParams{Database: catalogue})
s.storage = binarystorage.New("my-uuid", s.managedStorage, s.metadataCollection, s.txnRunner)
}
func (s *BakeryStorageSuite) initService(c *gc.C, enableExpiry bool) {
store, err := bakerystorage.New(bakerystorage.Config{
GetCollection: func() (mongo.Collection, func()) {
return mongo.CollectionFromName(s.db, s.coll.Name)
},
})
c.Assert(err, jc.ErrorIsNil)
if enableExpiry {
store = store.ExpireAt(time.Now())
}
s.store = store
service, err := bakery.NewService(bakery.NewServiceParams{
Location: "straya",
Store: s.store,
})
c.Assert(err, jc.ErrorIsNil)
s.service = service
}
func (s *cloudImageMetadataSuite) TestSaveAndFindMetadata(c *gc.C) {
metadata, err := s.client.List("", "", nil, nil, "", "")
c.Assert(err, gc.ErrorMatches, "matching cloud image metadata not found")
c.Assert(metadata, gc.HasLen, 0)
// check db too
conn := s.State.MongoSession()
coll, closer := mongo.CollectionFromName(conn.DB("juju"), "cloudimagemetadata")
defer closer()
before, err := coll.Count()
c.Assert(err, jc.ErrorIsNil)
c.Assert(before == 0, jc.IsTrue)
m := params.CloudImageMetadata{
Source: "custom",
Stream: "stream",
Region: "region",
Series: "series",
Arch: "arch",
VirtualType: "virtType",
RootStorageType: "rootStorageType",
ImageId: "1",
}
errs, err := s.client.Save([]params.CloudImageMetadata{m})
c.Assert(err, jc.ErrorIsNil)
c.Assert(errs, gc.HasLen, 1)
c.Assert(errs[0].Error, gc.IsNil)
added, err := s.client.List("", "", nil, nil, "", "")
c.Assert(err, jc.ErrorIsNil)
c.Assert(added, jc.DeepEquals, []params.CloudImageMetadata{m})
// make sure it's in db too
after, err := coll.Count()
c.Assert(err, jc.ErrorIsNil)
c.Assert(after == 1, jc.IsTrue)
}
func (m *TestMongo) GetCollection(name string) (mongo.Collection, func()) {
return mongo.CollectionFromName(m.database, name)
}
func isAlive(db *mgo.Database, collName string, id interface{}) (bool, error) {
coll, closer := mongo.CollectionFromName(db, collName)
defer closer()
return isAliveWithSession(coll, id)
}
// getRawCollection returns the named mgo Collection. As no automatic
// environment filtering is performed by the returned collection it
// should be rarely used. getCollection() should be used in almost all
// cases.
func (st *State) getRawCollection(name string) (*mgo.Collection, func()) {
collection, closer := mongo.CollectionFromName(st.db, name)
return collection.Writeable().Underlying(), closer
}
// getCollection fetches a named collection using a new session if the
// database has previously been logged in to. It returns the
// collection and a closer function for the session.
//
// If the collection stores documents for multiple environments, the
// returned collection will automatically perform environment
// filtering where possible. See envStateCollection below.
func (st *State) getCollection(name string) (mongo.Collection, func()) {
collection, closer := mongo.CollectionFromName(st.db, name)
return newStateCollection(collection, st.EnvironUUID()), closer
}
