func (*suite) TestParseBinary(c *gc.C) {
for i, test := range parseBinaryTests {
c.Logf("test 1: %d", i)
got, err := version.ParseBinary(test.v)
if test.err != "" {
c.Assert(err, gc.ErrorMatches, test.err)
} else {
c.Assert(err, gc.IsNil)
c.Assert(got, gc.Equals, test.expect)
}
}
for i, test := range parseTests {
c.Logf("test 2: %d", i)
v := test.v + "-a-b"
got, err := version.ParseBinary(v)
expect := version.Binary{
Number: test.expect,
Series: "a",
Arch: "b",
}
if test.err != "" {
c.Assert(err, gc.ErrorMatches, strings.Replace(test.err, "version", "binary version", 1))
} else {
c.Assert(err, gc.IsNil)
c.Assert(got, gc.Equals, expect)
c.Check(got.IsDev(), gc.Equals, test.dev)
}
}
}
// ReadList returns a List of the tools in store with the given major.minor version.
// If minorVersion = -1, then only majorVersion is considered.
// If store contains no such tools, it returns ErrNoMatches.
func ReadList(stor storage.StorageReader, majorVersion, minorVersion int) (coretools.List, error) {
if minorVersion >= 0 {
logger.Debugf("reading v%d.%d tools", majorVersion, minorVersion)
} else {
logger.Debugf("reading v%d.* tools", majorVersion)
}
names, err := storage.List(stor, toolPrefix)
if err != nil {
return nil, err
}
var list coretools.List
var foundAnyTools bool
for _, name := range names {
if !strings.HasPrefix(name, toolPrefix) || !strings.HasSuffix(name, toolSuffix) {
continue
}
var t coretools.Tools
vers := name[len(toolPrefix) : len(name)-len(toolSuffix)]
if t.Version, err = version.ParseBinary(vers); err != nil {
logger.Debugf("failed to parse version %q: %v", vers, err)
continue
}
foundAnyTools = true
// Major version must match specified value.
if t.Version.Major != majorVersion {
continue
}
// If specified minor version value supplied, minor version must match.
if minorVersion >= 0 && t.Version.Minor != minorVersion {
continue
}
logger.Debugf("found %s", vers)
if t.URL, err = stor.URL(name); err != nil {
return nil, err
}
list = append(list, &t)
}
if len(list) == 0 {
if foundAnyTools {
return nil, coretools.ErrNoMatches
}
return nil, ErrNoTools
}
return list, nil
}
// processPost handles a charm upload POST request after authentication.
func (h *toolsHandler) processPost(r *http.Request) (*tools.Tools, bool, error) {
query := r.URL.Query()
binaryVersionParam := query.Get("binaryVersion")
if binaryVersionParam == "" {
return nil, false, fmt.Errorf("expected binaryVersion argument")
}
toolsVersion, err := version.ParseBinary(binaryVersionParam)
if err != nil {
return nil, false, fmt.Errorf("invalid tools version %q: %v", binaryVersionParam, err)
}
var fakeSeries []string
seriesParam := query.Get("series")
if seriesParam != "" {
fakeSeries = strings.Split(seriesParam, ",")
}
logger.Debugf("request to upload tools %s for series %q", toolsVersion, seriesParam)
// Make sure the content type is x-tar-gz.
contentType := r.Header.Get("Content-Type")
if contentType != "application/x-tar-gz" {
return nil, false, fmt.Errorf("expected Content-Type: application/x-tar-gz, got: %v", contentType)
}
return h.handleUpload(r.Body, toolsVersion, fakeSeries...)
}
// BundleTools bundles all the current juju tools in gzipped tar
// format to the given writer.
// If forceVersion is not nil, a FORCE-VERSION file is included in
// the tools bundle so it will lie about its current version number.
func BundleTools(w io.Writer, forceVersion *version.Number) (tvers version.Binary, sha256Hash string, err error) {
dir, err := ioutil.TempDir("", "juju-tools")
if err != nil {
return version.Binary{}, "", err
}
defer os.RemoveAll(dir)
if err := copyExistingJujud(dir); err != nil {
logger.Debugf("copy existing failed: %v", err)
if err := buildJujud(dir); err != nil {
return version.Binary{}, "", err
}
}
if forceVersion != nil {
logger.Debugf("forcing version to %s", forceVersion)
if err := ioutil.WriteFile(filepath.Join(dir, "FORCE-VERSION"), []byte(forceVersion.String()), 0666); err != nil {
return version.Binary{}, "", err
}
}
cmd := exec.Command(filepath.Join(dir, "jujud"), "version")
out, err := cmd.CombinedOutput()
if err != nil {
return version.Binary{}, "", fmt.Errorf("cannot get version from %q: %v; %s", cmd.Args[0], err, out)
}
tvs := strings.TrimSpace(string(out))
tvers, err = version.ParseBinary(tvs)
if err != nil {
return version.Binary{}, "", fmt.Errorf("invalid version %q printed by jujud", tvs)
}
sha256Hash, err = archive(w, dir)
if err != nil {
return version.Binary{}, "", err
}
return tvers, sha256Hash, err
}
