func (s *resourceCatalogSuite) TestPutDeletedResourceRace(c *gc.C) {
firstId, _ := s.assertPut(c, true, "md5foo", "sha256foo")
err := s.rCatalog.UploadComplete(firstId)
c.Assert(err, gc.IsNil)
beforeFuncs := []func(){
func() {
_, _, err := s.rCatalog.Remove(firstId)
c.Assert(err, gc.IsNil)
},
}
defer txntesting.SetBeforeHooks(c, s.txnRunner, beforeFuncs...).Check()
rh := &storage.ResourceHash{"md5foo", "sha256foo"}
id, _, isNew, err := s.rCatalog.Put(rh, 200)
c.Assert(err, gc.IsNil)
c.Assert(isNew, jc.IsTrue)
c.Assert(firstId, gc.Equals, id)
err = s.rCatalog.UploadComplete(id)
c.Assert(err, gc.IsNil)
r, err := s.rCatalog.Get(id)
c.Assert(err, gc.IsNil)
s.assertRefCount(c, id, 1)
c.Assert(r.MD5Hash, gc.Equals, "md5foo")
c.Assert(r.SHA256Hash, gc.Equals, "sha256foo")
c.Assert(r.Length, gc.Equals, int64(200))
}
func (s *txnSuite) TestBeforeHooks(c *gc.C) {
s.insertDoc(c, "1", "Simple")
changeFuncs := []func(){
func() { s.setDocName(c, "1", "FooBar") },
func() { s.setDocName(c, "1", "Foo") },
}
defer txntesting.SetBeforeHooks(c, s.txnRunner, changeFuncs...).Check()
maxAttempt := 0
buildTxn := func(attempt int) ([]txn.Op, error) {
maxAttempt = attempt
ops := []txn.Op{{
C: s.collection.Name,
Id: "1",
Assert: bson.D{{"name", "Foo"}},
Update: bson.D{{"$set", bson.D{{"name", "Bar"}}}},
}}
return ops, nil
}
err := s.txnRunner.Run(buildTxn)
c.Assert(err, gc.IsNil)
var found simpleDoc
err = s.collection.FindId("1").One(&found)
c.Assert(err, gc.IsNil)
c.Assert(maxAttempt, gc.Equals, 1)
doc := simpleDoc{"1", "Bar"}
c.Assert(found, gc.DeepEquals, doc)
}
func (s *managedStorageSuite) TestPutRace(c *gc.C) {
blob := []byte("some resource")
beforeFunc := func() {
s.assertPut(c, "/path/to/blob", blob)
}
defer txntesting.SetBeforeHooks(c, s.txnRunner, beforeFunc).Check()
anotherblob := []byte("another resource")
s.assertPut(c, "/path/to/blob", anotherblob)
s.assertResourceCatalogCount(c, 1)
}
func (s *managedStorageSuite) TestPutDeleteRace(c *gc.C) {
blob := []byte("some resource")
s.assertPut(c, "/path/to/blob", blob)
beforeFunc := func() {
err := s.managedStorage.RemoveForEnvironment("env", "/path/to/blob")
c.Assert(err, gc.IsNil)
}
defer txntesting.SetBeforeHooks(c, s.txnRunner, beforeFunc).Check()
anotherblob := []byte("another resource")
s.assertPut(c, "/path/to/blob", anotherblob)
s.assertResourceCatalogCount(c, 1)
}
func (s *managedStorageSuite) TestRemoveRace(c *gc.C) {
blob := []byte("some resource")
s.assertPut(c, "/path/to/blob", blob)
beforeFunc := func() {
err := s.managedStorage.RemoveForEnvironment("env", "/path/to/blob")
c.Assert(err, gc.IsNil)
}
defer txntesting.SetBeforeHooks(c, s.txnRunner, beforeFunc).Check()
err := s.managedStorage.RemoveForEnvironment("env", "/path/to/blob")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
_, _, err = s.managedStorage.GetForEnvironment("env", "/path/to/blob")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *resourceCatalogSuite) TestDeleteResourceRace(c *gc.C) {
id, _ := s.assertPut(c, true, "md5foo", "sha256foo")
s.assertPut(c, false, "md5foo", "sha256foo")
beforeFuncs := []func(){
func() {
_, _, err := s.rCatalog.Remove(id)
c.Assert(err, gc.IsNil)
},
}
defer txntesting.SetBeforeHooks(c, s.txnRunner, beforeFuncs...).Check()
_, _, err := s.rCatalog.Remove(id)
c.Assert(err, gc.IsNil)
_, err = s.rCatalog.Get(id)
c.Assert(err, gc.ErrorMatches, `resource with id ".*" not found`)
}
func (s *managedStorageSuite) TestPutRaceWhereCatalogEntryRemoved(c *gc.C) {
blob := []byte("some resource")
// Remove the resource catalog entry with the resourceId that we are about
// to write to a managed resource entry.
beforeFunc := []func(){
nil, // resourceCatalog Put()
nil, // managedResource Put()
func() {
// Shamelessly exploit our knowledge of how ids are made.
md5hash, sha256hash := calculateCheckSums(c, 0, int64(len(blob)), blob)
_, _, err := storage.GetResourceCatalog(s.managedStorage).Remove(md5hash + sha256hash)
c.Assert(err, gc.IsNil)
},
}
defer txntesting.SetBeforeHooks(c, s.txnRunner, beforeFunc...).Check()
rdr := bytes.NewReader(blob)
err := s.managedStorage.PutForEnvironment("env", "/path/to/blob", rdr, int64(len(blob)))
c.Assert(err, gc.ErrorMatches, "unexpected deletion .*")
s.assertResourceCatalogCount(c, 0)
}
func (s *resourceCatalogSuite) TestPutNewResourceRace(c *gc.C) {
var firstId string
beforeFuncs := []func(){
func() { firstId, _ = s.assertPut(c, true, "md5foo", "sha256foo") },
}
defer txntesting.SetBeforeHooks(c, s.txnRunner, beforeFuncs...).Check()
rh := &storage.ResourceHash{"md5foo", "sha256foo"}
id, _, isNew, err := s.rCatalog.Put(rh, 200)
c.Assert(err, gc.IsNil)
c.Assert(id, gc.Equals, firstId)
c.Assert(isNew, jc.IsFalse)
err = s.rCatalog.UploadComplete(id)
c.Assert(err, gc.IsNil)
r, err := s.rCatalog.Get(id)
c.Assert(err, gc.IsNil)
s.assertRefCount(c, id, 2)
c.Assert(r.MD5Hash, gc.Equals, "md5foo")
c.Assert(r.SHA256Hash, gc.Equals, "sha256foo")
c.Assert(int(r.Length), gc.Equals, 200)
}
func SetBeforeHooks(c *gc.C, st *State, fs ...func()) txntesting.TransactionChecker {
return txntesting.SetBeforeHooks(c, st.transactionRunner, fs...)
}
