Ejemplo n.º 1
0
func createBundle(name, outdir, contentdir, root string) (string, error) {
	archive, err := os.Create(filepath.Join(outdir, name))
	if err != nil {
		return "", errors.Annotate(err, "error opening archive file")
	}
	defer archive.Close()

	// Build the tarball, writing out to both the archive file and a
	// SHA1 hash.  The hash will correspond to the gzipped file rather
	// than to the uncompressed contents of the tarball.  This is so
	// that users can compare the published checksum against the
	// checksum of the file without having to decompress it first.
	hasher := hash.NewHashingWriter(archive, sha1.New())
	err = func() error {
		tarball := gzip.NewWriter(hasher)
		defer tarball.Close()

		_, err := tar.TarFiles([]string{contentdir}, tarball, root)
		return err
	}()
	if err != nil {
		return "", errors.Annotate(err, "error bundling final archive")
	}

	// Return the SHA1 checksum.
	// Gzip writers may buffer what they're writing so we must call
	// Close() on the writer *before* getting the checksum from the
	// hasher.
	return hasher.Base64Sum(), nil
}
Ejemplo n.º 2
0
func (s *WriterSuite) TestHashingWriterHexSum(c *gc.C) {
	var buf bytes.Buffer
	hasher := fakeHasher{sum: []byte("spam")}
	w := hash.NewHashingWriter(&buf, &hasher)
	rawhash := w.HexSum()

	c.Check(rawhash, gc.Equals, "7370616d")
}
Ejemplo n.º 3
0
func (s *WriterSuite) TestHashingWriterSum(c *gc.C) {
	var buf bytes.Buffer
	hasher := fakeHasher{sum: []byte("spam")}
	w := hash.NewHashingWriter(&buf, &hasher)
	b64hash := string(w.Sum())

	c.Check(b64hash, gc.Equals, "spam")
}
Ejemplo n.º 4
0
func (s *WriterSuite) TestHashingWriterBase64Sum(c *gc.C) {
	var buf bytes.Buffer
	hasher := fakeHasher{sum: []byte("spam")}
	w := hash.NewHashingWriter(&buf, &hasher)
	b64hash := w.Base64Sum()

	c.Check(b64hash, gc.Equals, "c3BhbQ==")
}
Ejemplo n.º 5
0
func (s *WriterSuite) TestHashingWriterBase64Sum(c *gc.C) {
	s.hash.ReturnSum = []byte("spam")
	w := hash.NewHashingWriter(s.writer, s.hash)
	b64sum := w.Base64Sum()

	s.stub.CheckCallNames(c, "Sum")
	c.Check(b64sum, gc.Equals, "c3BhbQ==")
}
Ejemplo n.º 6
0
func (s *WriterSuite) TestHashingWriterWriteFileError(c *gc.C) {
	file := errorWriter{err: errors.New("failed!")}
	hasher := fakeHasher{}
	w := hash.NewHashingWriter(&file, &hasher)
	_, err := w.Write([]byte("spam"))

	c.Check(err, gc.ErrorMatches, "failed!")
}
Ejemplo n.º 7
0
func (s *WriterSuite) TestHashingWriterWriteFileError(c *gc.C) {
	w := hash.NewHashingWriter(s.writer, s.hash)
	failure := errors.New("<failed>")
	s.stub.SetErrors(failure)

	_, err := w.Write([]byte("spam"))

	s.stub.CheckCallNames(c, "Write")
	c.Check(errors.Cause(err), gc.Equals, failure)
}
Ejemplo n.º 8
0
func (s *WriterSuite) TestHashingWriterWriteSmall(c *gc.C) {
	w := hash.NewHashingWriter(s.writer, s.hash)
	n, err := w.Write([]byte("spam"))
	c.Assert(err, jc.ErrorIsNil)

	s.stub.CheckCallNames(c, "Write", "Write")
	c.Check(n, gc.Equals, 4)
	c.Check(s.wBuffer.String(), gc.Equals, "spam")
	c.Check(s.hBuffer.String(), gc.Equals, "spam")
}
Ejemplo n.º 9
0
func (s *WriterSuite) TestHashingWriterWriteEmpty(c *gc.C) {
	w := hash.NewHashingWriter(s.writer, s.hash)
	n, err := w.Write(nil)
	c.Assert(err, jc.ErrorIsNil)

	s.stub.CheckCallNames(c, "Write", "Write")
	c.Check(n, gc.Equals, 0)
	c.Check(s.wBuffer.String(), gc.Equals, "")
	c.Check(s.hBuffer.String(), gc.Equals, "")
}
Ejemplo n.º 10
0
func (s *WriterSuite) TestHashingWriterWriteSmall(c *gc.C) {
	var buf bytes.Buffer
	hasher := fakeHasher{}
	w := hash.NewHashingWriter(&buf, &hasher)
	n, err := w.Write([]byte("spam"))

	c.Check(err, gc.IsNil)
	c.Check(n, gc.Equals, 4)
	c.Check(buf.String(), gc.Equals, "spam")
	c.Check(hasher.String(), gc.Equals, "spam")
}
Ejemplo n.º 11
0
func (s *WriterSuite) TestHashingWriterWriteEmpty(c *gc.C) {
	var buf bytes.Buffer
	hasher := fakeHasher{}
	w := hash.NewHashingWriter(&buf, &hasher)
	n, err := w.Write(nil)

	c.Check(err, gc.IsNil)
	c.Check(n, gc.Equals, 0)
	c.Check(buf.String(), gc.Equals, "")
	c.Check(hasher.String(), gc.Equals, "")
}
Ejemplo n.º 12
0
func (b *builder) buildArchiveAndChecksum() error {
	logger.Infof("building archive file (%s)", b.archive.Filename)
	if b.archiveFile == nil {
		return errors.New("missing archiveFile")
	}

	// Build the tarball, writing out to both the archive file and a
	// SHA1 hash.  The hash will correspond to the gzipped file rather
	// than to the uncompressed contents of the tarball.  This is so
	// that users can compare the published checksum against the
	// checksum of the file without having to decompress it first.
	hasher := hash.NewHashingWriter(b.archiveFile, sha1.New())
	if err := b.buildArchive(hasher); err != nil {
		return errors.Trace(err)
	}

	// Save the SHA1 checksum.
	// Gzip writers may buffer what they're writing so we must call
	// Close() on the writer *before* getting the checksum from the
	// hasher.
	b.checksum = hasher.Base64Sum()

	return nil
}