// FinishMetadata finishes a metadata with test values.
func FinishMetadata(meta *backups.Metadata) {
var size int64 = 10
checksum := "787b8915389d921fa23fb40e16ae81ea979758bf"
meta.MarkComplete(size, checksum)
finished := meta.Started.Add(time.Minute)
meta.Finished = &finished
}
func (s *storageSuite) checkMeta(c *gc.C, meta, expected *backups.Metadata, id string,
) {
if id != "" {
c.Check(meta.ID(), gc.Equals, id)
}
c.Check(meta.Notes, gc.Equals, expected.Notes)
c.Check(meta.Started.Unix(), gc.Equals, expected.Started.Unix())
c.Check(meta.Checksum(), gc.Equals, expected.Checksum())
c.Check(meta.ChecksumFormat(), gc.Equals, expected.ChecksumFormat())
c.Check(meta.Size(), gc.Equals, expected.Size())
c.Check(meta.Origin.Model, gc.Equals, expected.Origin.Model)
c.Check(meta.Origin.Machine, gc.Equals, expected.Origin.Machine)
c.Check(meta.Origin.Hostname, gc.Equals, expected.Origin.Hostname)
c.Check(meta.Origin.Version, gc.Equals, expected.Origin.Version)
if meta.Stored() != nil && expected.Stored() != nil {
c.Check(meta.Stored().Unix(), gc.Equals, expected.Stored().Unix())
} else {
c.Check(meta.Stored(), gc.Equals, expected.Stored())
}
}
// NewArchive returns a new archive file containing the files.
func NewArchive(meta *backups.Metadata, files, dump []File) (*bytes.Buffer, error) {
dirs := set.NewStrings()
var sysFiles []File
for _, file := range files {
var parent string
for _, p := range strings.Split(path.Dir(file.Name), "/") {
if parent == "" {
parent = p
} else {
parent = path.Join(parent, p)
}
if !dirs.Contains(parent) {
sysFiles = append(sysFiles, File{
Name: parent,
IsDir: true,
})
dirs.Add(parent)
}
}
if file.IsDir {
if !dirs.Contains(file.Name) {
sysFiles = append(sysFiles, file)
dirs.Add(file.Name)
}
} else {
sysFiles = append(sysFiles, file)
}
}
var rootFile bytes.Buffer
if err := writeToTar(&rootFile, sysFiles); err != nil {
return nil, errors.Trace(err)
}
topfiles := []File{{
Name: "juju-backup",
IsDir: true,
}}
topfiles = append(topfiles, File{
Name: "juju-backup/dump",
IsDir: true,
})
for _, dumpFile := range dump {
topfiles = append(topfiles, File{
Name: "juju-backup/dump/" + dumpFile.Name,
Content: dumpFile.Content,
IsDir: dumpFile.IsDir,
})
}
topfiles = append(topfiles,
File{
Name: "juju-backup/root.tar",
Content: rootFile.String(),
},
)
if meta != nil {
metaFile, err := meta.AsJSONBuffer()
if err != nil {
return nil, errors.Trace(err)
}
topfiles = append(topfiles,
File{
Name: "juju-backup/metadata.json",
Content: metaFile.(*bytes.Buffer).String(),
},
)
}
var arFile bytes.Buffer
compressed := gzip.NewWriter(&arFile)
defer compressed.Close()
if err := writeToTar(compressed, topfiles); err != nil {
return nil, errors.Trace(err)
}
return &arFile, nil
}
func (s *baseSuite) checkMetadataResult(c *gc.C, result *params.BackupsMetadataResult, meta *stbackups.Metadata) {
var finished, stored time.Time
if meta.Finished != nil {
finished = *meta.Finished
}
if meta.Stored() != nil {
stored = *(meta.Stored())
}
c.Check(result.ID, gc.Equals, meta.ID())
c.Check(result.Started, gc.Equals, meta.Started)
c.Check(result.Finished, gc.Equals, finished)
c.Check(result.Checksum, gc.Equals, meta.Checksum())
c.Check(result.ChecksumFormat, gc.Equals, meta.ChecksumFormat())
c.Check(result.Size, gc.Equals, meta.Size())
c.Check(result.Stored, gc.Equals, stored)
c.Check(result.Notes, gc.Equals, meta.Notes)
c.Check(result.Environment, gc.Equals, meta.Origin.Environment)
c.Check(result.Machine, gc.Equals, meta.Origin.Machine)
c.Check(result.Hostname, gc.Equals, meta.Origin.Hostname)
c.Check(result.Version, gc.Equals, meta.Origin.Version)
}
// ResultFromMetadata updates the result with the information in the
// metadata value.
func ResultFromMetadata(meta *backups.Metadata) params.BackupsMetadataResult {
var result params.BackupsMetadataResult
result.ID = meta.ID()
result.Checksum = meta.Checksum()
result.ChecksumFormat = meta.ChecksumFormat()
result.Size = meta.Size()
if meta.Stored() != nil {
result.Stored = *(meta.Stored())
}
result.Started = meta.Started
if meta.Finished != nil {
result.Finished = *meta.Finished
}
result.Notes = meta.Notes
result.Environment = meta.Origin.Environment
result.Machine = meta.Origin.Machine
result.Hostname = meta.Origin.Hostname
result.Version = meta.Origin.Version
return result
}
// ResultFromMetadata updates the result with the information in the
// metadata value.
func ResultFromMetadata(meta *backups.Metadata) params.BackupsMetadataResult {
var result params.BackupsMetadataResult
result.ID = meta.ID()
result.Checksum = meta.Checksum()
result.ChecksumFormat = meta.ChecksumFormat()
result.Size = meta.Size()
if meta.Stored() != nil {
result.Stored = *(meta.Stored())
}
result.Started = meta.Started
if meta.Finished != nil {
result.Finished = *meta.Finished
}
result.Notes = meta.Notes
result.Model = meta.Origin.Model
result.Machine = meta.Origin.Machine
result.Hostname = meta.Origin.Hostname
result.Version = meta.Origin.Version
result.Series = meta.Origin.Series
// TODO(wallyworld) - remove these ASAP
// These are only used by the restore CLI when re-bootstrapping.
// We will use a better solution but the way restore currently
// works, we need them and they are no longer available via
// bootstrap config. We will need to ifx how re-bootstrap deals
// with these keys to address the issue.
result.CACert = meta.CACert
result.CAPrivateKey = meta.CAPrivateKey
return result
}