func (s *backupsSuite) checkFailure(c *gc.C, expected string) {
dbInfo := db.ConnInfo{"a", "b", "c"}
origin := metadata.NewOrigin("<env ID>", "<machine ID>", "<hostname>")
_, err := s.api.Create(dbInfo, *origin, "some notes")
c.Check(err, gc.ErrorMatches, expected)
}
func (s *backupsSuite) TestCreateOkay(c *gc.C) {
// Patch the internals.
archiveFile := ioutil.NopCloser(bytes.NewBufferString("<compressed tarball>"))
result := backups.NewTestCreateResult(archiveFile, 10, "<checksum>")
received, testCreate := backups.NewTestCreate(result)
s.PatchValue(backups.RunCreate, testCreate)
rootDir := "<was never set>"
s.PatchValue(backups.GetFilesToBackUp, func(root string) ([]string, error) {
rootDir = root
return []string{"<some file>"}, nil
})
var receivedDBInfo *db.ConnInfo
s.PatchValue(backups.GetDBDumper, func(info db.ConnInfo) db.Dumper {
receivedDBInfo = &info
return nil
})
// Run the backup.
dbInfo := db.ConnInfo{"a", "b", "c"}
origin := metadata.NewOrigin("<env ID>", "<machine ID>", "<hostname>")
meta, err := s.api.Create(dbInfo, *origin, "some notes")
// Test the call values.
filesToBackUp, _ := backups.ExposeCreateArgs(received)
c.Check(filesToBackUp, jc.SameContents, []string{"<some file>"})
err = receivedDBInfo.Validate()
c.Assert(err, gc.IsNil)
c.Check(receivedDBInfo.Address, gc.Equals, "a")
c.Check(receivedDBInfo.Username, gc.Equals, "b")
c.Check(receivedDBInfo.Password, gc.Equals, "c")
c.Check(rootDir, gc.Equals, "")
// Check the resulting metadata.
c.Check(meta.ID(), gc.Not(gc.Equals), "")
c.Check(meta.Size(), gc.Equals, int64(10))
c.Check(meta.Checksum(), gc.Equals, "<checksum>")
c.Check(meta.Stored(), gc.Equals, true)
metaOrigin := meta.Origin()
c.Check(metaOrigin.Environment(), gc.Equals, "<env ID>")
c.Check(metaOrigin.Machine(), gc.Equals, "<machine ID>")
c.Check(metaOrigin.Hostname(), gc.Equals, "<hostname>")
c.Check(meta.Notes(), gc.Equals, "some notes")
// Check the file storage.
storedMeta, storedFile, err := s.storage.Get(meta.ID())
c.Check(err, gc.IsNil)
c.Check(storedMeta, gc.DeepEquals, meta)
data, err := ioutil.ReadAll(storedFile)
c.Assert(err, gc.IsNil)
c.Check(string(data), gc.Equals, "<compressed tarball>")
}
func (s *backupSuite) metadata(c *gc.C) *metadata.Metadata {
origin := metadata.NewOrigin(
s.State.EnvironTag().Id(),
"0",
"localhost",
)
meta := metadata.NewMetadata(*origin, "", nil)
err := meta.Finish(int64(42), "some hash", "", nil)
c.Assert(err, gc.IsNil)
return meta
}
// NewBackupsOrigin returns a snapshot of where backup was run. That
// snapshot is a new backup Origin value, for use in a backup's
// metadata. Every value except for the machine name is populated
// either from juju state or some other implicit mechanism.
func NewBackupsOrigin(st *State, machine string) *metadata.Origin {
// hostname could be derived from the environment...
hostname, err := os.Hostname()
if err != nil {
// If os.Hostname() is not working, something is woefully wrong.
// Run for the hills.
panic(fmt.Sprintf("could not get hostname (system unstable?): %v", err))
}
origin := metadata.NewOrigin(
st.EnvironTag().Id(),
machine,
hostname,
)
return origin
}
func (s *backupsSuite) newMeta(notes string) *metadata.Metadata {
origin := metadata.NewOrigin("<env ID>", "<machine ID>", "<hostname>")
return metadata.NewMetadata(*origin, notes, nil)
}