func (t *ToolsSuite) TestChangeAgentTools(c *gc.C) {
files := []*testing.TarFile{
testing.NewTarFile("jujuc", agenttools.DirPerm, "juju executable"),
testing.NewTarFile("jujud", agenttools.DirPerm, "jujuc executable"),
}
data, checksum := testing.TarGz(files...)
testTools := &coretest.Tools{
URL: "http://foo/bar1",
Version: version.MustParseBinary("1.2.3-quantal-amd64"),
Size: int64(len(data)),
SHA256: checksum,
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(data))
c.Assert(err, jc.ErrorIsNil)
gotTools, err := agenttools.ChangeAgentTools(t.dataDir, "testagent", testTools.Version)
c.Assert(err, jc.ErrorIsNil)
c.Assert(*gotTools, gc.Equals, *testTools)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-quantal-amd64", "testagent"})
assertDirNames(c, agenttools.ToolsDir(t.dataDir, "testagent"), []string{"jujuc", "jujud", agenttools.ToolsFile})
// Upgrade again to check that the link replacement logic works ok.
files2 := []*testing.TarFile{
testing.NewTarFile("quantal", agenttools.DirPerm, "foo content"),
testing.NewTarFile("amd64", agenttools.DirPerm, "bar content"),
}
data2, checksum2 := testing.TarGz(files2...)
tools2 := &coretest.Tools{
URL: "http://foo/bar2",
Version: version.MustParseBinary("1.2.4-quantal-amd64"),
Size: int64(len(data2)),
SHA256: checksum2,
}
err = agenttools.UnpackTools(t.dataDir, tools2, bytes.NewReader(data2))
c.Assert(err, jc.ErrorIsNil)
gotTools, err = agenttools.ChangeAgentTools(t.dataDir, "testagent", tools2.Version)
c.Assert(err, jc.ErrorIsNil)
c.Assert(*gotTools, gc.Equals, *tools2)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-quantal-amd64", "1.2.4-quantal-amd64", "testagent"})
assertDirNames(c, agenttools.ToolsDir(t.dataDir, "testagent"), []string{"quantal", "amd64", agenttools.ToolsFile})
}
// InstallFakeDownloadedTools creates and unpacks fake tools of the
// given version into the data directory specified.
func InstallFakeDownloadedTools(c *gc.C, dataDir string, vers version.Binary) *coretools.Tools {
tgz, checksum := makeFakeTools(vers)
agentTools := &coretools.Tools{
Version: vers,
Size: int64(len(tgz)),
SHA256: checksum,
}
err := agenttools.UnpackTools(dataDir, agentTools, bytes.NewReader(tgz))
c.Assert(err, jc.ErrorIsNil)
return agentTools
}
// PrimeTools sets up the current version of the tools to vers and
// makes sure that they're available in the dataDir.
func PrimeTools(c *gc.C, stor storage.Storage, dataDir, toolsDir string, vers version.Binary) *coretools.Tools {
err := os.RemoveAll(filepath.Join(dataDir, "tools"))
c.Assert(err, jc.ErrorIsNil)
agentTools, err := uploadFakeToolsVersion(stor, toolsDir, vers)
c.Assert(err, jc.ErrorIsNil)
resp, err := utils.GetValidatingHTTPClient().Get(agentTools.URL)
c.Assert(err, jc.ErrorIsNil)
defer resp.Body.Close()
err = agenttools.UnpackTools(dataDir, agentTools, resp.Body)
c.Assert(err, jc.ErrorIsNil)
return agentTools
}
func (t *ToolsSuite) TestUnpackToolsBadChecksum(c *gc.C) {
data, _ := testing.TarGz(testing.NewTarFile("tools", agenttools.DirPerm, "some data"))
testTools := &coretest.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-quantal-amd64"),
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{})
}
func (t *ToolsSuite) TestUnpackToolsBadData(c *gc.C) {
for i, test := range unpackToolsBadDataTests {
c.Logf("test %d", i)
testTools := &coretest.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-quantal-amd64"),
Size: int64(len(test.data)),
SHA256: test.checksum,
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(test.data))
c.Assert(err, gc.ErrorMatches, test.err)
assertDirNames(c, t.toolsDir(), []string{})
}
}
func (t *ToolsSuite) TestUnpackToolsContents(c *gc.C) {
files := []*testing.TarFile{
testing.NewTarFile("bar", agenttools.DirPerm, "bar contents"),
testing.NewTarFile("foo", agenttools.DirPerm, "foo contents"),
}
data, checksum := testing.TarGz(files...)
testTools := &coretest.Tools{
URL: "http://foo/bar",
Version: version.MustParseBinary("1.2.3-quantal-amd64"),
Size: int64(len(data)),
SHA256: checksum,
}
err := agenttools.UnpackTools(t.dataDir, testTools, bytes.NewReader(data))
c.Assert(err, jc.ErrorIsNil)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-quantal-amd64"})
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", agenttools.DirPerm, "bar2 contents"),
testing.NewTarFile("x", agenttools.DirPerm, "x contents"),
}
data2, checksum2 := testing.TarGz(files2...)
tools2 := &coretest.Tools{
URL: "http://arble",
Version: version.MustParseBinary("1.2.3-quantal-amd64"),
Size: int64(len(data2)),
SHA256: checksum2,
}
err = agenttools.UnpackTools(t.dataDir, tools2, bytes.NewReader(data2))
c.Assert(err, jc.ErrorIsNil)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-quantal-amd64"})
t.assertToolsContents(c, testTools, files)
}
func (u *Upgrader) ensureTools(agentTools *coretools.Tools, hostnameVerification utils.SSLHostnameVerification) error {
logger.Infof("fetching tools from %q", agentTools.URL)
client := utils.GetHTTPClient(hostnameVerification)
resp, err := client.Get(agentTools.URL)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("bad HTTP response: %v", resp.Status)
}
err = agenttools.UnpackTools(u.dataDir, agentTools, resp.Body)
if err != nil {
return fmt.Errorf("cannot unpack tools: %v", err)
}
logger.Infof("unpacked tools %s to %s", agentTools.Version, u.dataDir)
return nil
}
func (u *Upgrader) ensureTools(agentTools *coretools.Tools) error {
logger.Infof("fetching tools from %q", agentTools.URL)
// The reader MUST verify the tools' hash, so there is no
// need to validate the peer. We cannot anyway: see http://pad.lv/1261780.
resp, err := utils.GetNonValidatingHTTPClient().Get(agentTools.URL)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("bad HTTP response: %v", resp.Status)
}
err = agenttools.UnpackTools(u.dataDir, agentTools, resp.Body)
if err != nil {
return fmt.Errorf("cannot unpack tools: %v", err)
}
logger.Infof("unpacked tools %s to %s", agentTools.Version, u.dataDir)
return nil
}
