func (t *ToolsSuite) TestChangeAgentTools(c *gc.C) {
files := []*testing.TarFile{
testing.NewTarFile("jujuc", 0755, "juju executable"),
testing.NewTarFile("jujud", 0755, "jujuc executable"),
}
data, checksum := testing.TarGz(files...)
testTools := &coretest.Tools{
URL: "http://foo/bar1",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(data)),
SHA256: checksum,
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(data))
c.Assert(err, gc.IsNil)
gotTools, err := agenttools.ChangeAgentTools(t.dataDir, "testagent", testTools.Version)
c.Assert(err, gc.IsNil)
c.Assert(*gotTools, gc.Equals, *testTools)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar", "testagent"})
assertDirNames(c, agenttools.ToolsDir(t.dataDir, "testagent"), []string{"jujuc", "jujud", toolsFile})
// Upgrade again to check that the link replacement logic works ok.
files2 := []*testing.TarFile{
testing.NewTarFile("foo", 0755, "foo content"),
testing.NewTarFile("bar", 0755, "bar content"),
}
data2, checksum2 := testing.TarGz(files2...)
tools2 := &coretest.Tools{
URL: "http://foo/bar2",
Version: version.MustParseBinary("1.2.4-foo-bar"),
Size: int64(len(data2)),
SHA256: checksum2,
}
err = agenttools.UnpackTools(t.dataDir, tools2, bytes.NewReader(data2))
c.Assert(err, gc.IsNil)
gotTools, err = agenttools.ChangeAgentTools(t.dataDir, "testagent", tools2.Version)
c.Assert(err, gc.IsNil)
c.Assert(*gotTools, gc.Equals, *tools2)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar", "1.2.4-foo-bar", "testagent"})
assertDirNames(c, agenttools.ToolsDir(t.dataDir, "testagent"), []string{"foo", "bar", toolsFile})
}
func (t *ToolsSuite) TestUnpackToolsBadChecksum(c *gc.C) {
data, _ := testing.TarGz(testing.NewTarFile("tools", 0755, "some data"))
testTools := &coretest.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(data)),
SHA256: "1234",
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(data))
c.Assert(err, gc.ErrorMatches, "tarball sha256 mismatch, expected 1234, got .*")
_, err = os.Stat(t.toolsDir())
c.Assert(err, gc.FitsTypeOf, &os.PathError{})
}
// Copied from environs/agent/tools_test.go
func (s *DiskManagerSuite) TestUnpackToolsContents(c *gc.C) {
files := []*coretesting.TarFile{
coretesting.NewTarFile("bar", 0755, "bar contents"),
coretesting.NewTarFile("foo", 0755, "foo contents"),
}
gzfile, checksum := coretesting.TarGz(files...)
t1 := &coretools.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(gzfile)),
SHA256: checksum,
}
err := s.manager.UnpackTools(t1, bytes.NewReader(gzfile))
c.Assert(err, gc.IsNil)
assertDirNames(c, s.toolsDir(), []string{"1.2.3-foo-bar"})
s.assertToolsContents(c, t1, files)
// Try to unpack the same version of tools again - it should succeed,
// leaving the original version around.
files2 := []*coretesting.TarFile{
coretesting.NewTarFile("bar", 0755, "bar2 contents"),
coretesting.NewTarFile("x", 0755, "x contents"),
}
gzfile2, checksum2 := coretesting.TarGz(files2...)
t2 := &coretools.Tools{
URL: "http://arble",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(gzfile2)),
SHA256: checksum2,
}
err = s.manager.UnpackTools(t2, bytes.NewReader(gzfile2))
c.Assert(err, gc.IsNil)
assertDirNames(c, s.toolsDir(), []string{"1.2.3-foo-bar"})
s.assertToolsContents(c, t1, files)
}
func uploadFakeToolsVersion(stor storage.Storage, vers version.Binary) (*coretools.Tools, error) {
logger.Infof("uploading FAKE tools %s", vers)
tgz, checksum := coretesting.TarGz(
coretesting.NewTarFile("jujud", 0777, "jujud contents "+vers.String()))
size := int64(len(tgz))
name := envtools.StorageName(vers)
if err := stor.Put(name, bytes.NewReader(tgz), size); err != nil {
return nil, err
}
url, err := stor.URL(name)
if err != nil {
return nil, err
}
return &coretools.Tools{URL: url, Version: vers, Size: size, SHA256: checksum}, nil
}
func (t *ToolsSuite) TestUnpackToolsContents(c *gc.C) {
files := []*testing.TarFile{
testing.NewTarFile("bar", 0755, "bar contents"),
testing.NewTarFile("foo", 0755, "foo contents"),
}
data, checksum := testing.TarGz(files...)
testTools := &coretest.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(data)),
SHA256: checksum,
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(data))
c.Assert(err, gc.IsNil)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar"})
t.assertToolsContents(c, testTools, files)
// Try to unpack the same version of tools again - it should succeed,
// leaving the original version around.
files2 := []*testing.TarFile{
testing.NewTarFile("bar", 0755, "bar2 contents"),
testing.NewTarFile("x", 0755, "x contents"),
}
data2, checksum2 := testing.TarGz(files2...)
tools2 := &coretest.Tools{
URL: "http://arble",
Version: version.MustParseBinary("1.2.3-foo-bar"),
Size: int64(len(data2)),
SHA256: checksum2,
}
err = agenttools.UnpackTools(t.dataDir, tools2, bytes.NewReader(data2))
c.Assert(err, gc.IsNil)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar"})
t.assertToolsContents(c, testTools, files)
}
func initBadDataTest(name string, mode os.FileMode, contents string, err string) badDataTest {
var result badDataTest
result.data, result.checksum = testing.TarGz(testing.NewTarFile(name, mode, contents))
result.err = err
return result
}