// GetMockBuildTools returns a sync.BuildToolsTarballFunc implementation which generates
// a fake tools tarball.
func GetMockBuildTools(c *gc.C) sync.BuildToolsTarballFunc {
return func(forceVersion *version.Number, stream string) (*sync.BuiltTools, error) {
vers := version.Binary{
Number: version.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
if forceVersion != nil {
vers.Number = *forceVersion
}
tgz, checksum := coretesting.TarGz(
coretesting.NewTarFile(names.Jujud, 0777, "jujud contents "+vers.String()))
toolsDir, err := ioutil.TempDir("", "juju-tools-"+stream)
c.Assert(err, jc.ErrorIsNil)
name := "name"
ioutil.WriteFile(filepath.Join(toolsDir, name), tgz, 0777)
return &sync.BuiltTools{
Dir: toolsDir,
StorageName: name,
Version: vers,
Size: int64(len(tgz)),
Sha256Hash: checksum,
}, nil
}
}
func (s *toolsStorage) toolsMetadata(v version.Binary) (toolsMetadataDoc, error) {
var doc toolsMetadataDoc
err := s.metadataCollection.Find(bson.D{{"_id", v.String()}}).One(&doc)
if err == mgo.ErrNotFound {
return doc, errors.NotFoundf("%v tools metadata", v)
}
return doc, err
}
// ValidateToolsMetadata attempts to load tools metadata for the specified cloud attributes and returns
// any tools versions found, or an error if the metadata could not be loaded.
func ValidateToolsMetadata(params *ToolsMetadataLookupParams) ([]string, *simplestreams.ResolveInfo, error) {
if len(params.Architectures) == 0 {
return nil, nil, fmt.Errorf("required parameter arches not specified")
}
if len(params.Sources) == 0 {
return nil, nil, fmt.Errorf("required parameter sources not specified")
}
if params.Version == "" && params.Major == 0 {
params.Version = version.Current.Number.String()
}
var toolsConstraint *ToolsConstraint
if params.Version == "" {
toolsConstraint = NewGeneralToolsConstraint(params.Major, params.Minor, simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: params.Region,
Endpoint: params.Endpoint,
},
Stream: params.Stream,
Series: []string{params.Series},
Arches: params.Architectures,
})
} else {
versNum, err := version.Parse(params.Version)
if err != nil {
return nil, nil, err
}
toolsConstraint = NewVersionedToolsConstraint(versNum, simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: params.Region,
Endpoint: params.Endpoint,
},
Stream: params.Stream,
Series: []string{params.Series},
Arches: params.Architectures,
})
}
matchingTools, resolveInfo, err := Fetch(params.Sources, toolsConstraint, false)
if err != nil {
return nil, resolveInfo, err
}
if len(matchingTools) == 0 {
return nil, resolveInfo, fmt.Errorf("no matching tools found for constraint %+v", toolsConstraint)
}
versions := make([]string, len(matchingTools))
for i, tm := range matchingTools {
vers := version.Binary{
Number: version.MustParse(tm.Version),
Series: tm.Release,
Arch: tm.Arch,
}
versions[i] = vers.String()
}
return versions, resolveInfo, nil
}
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 (s *ToolsSuite) addMetadataDoc(c *gc.C, v version.Binary, size int64, hash, path string) {
doc := struct {
Id string `bson:"_id"`
Version version.Binary `bson:"version"`
Size int64 `bson:"size"`
SHA256 string `bson:"sha256,omitempty"`
Path string `bson:"path"`
}{
Id: v.String(),
Version: v,
Size: size,
SHA256: hash,
Path: path,
}
err := s.metadataCollection.Insert(&doc)
c.Assert(err, jc.ErrorIsNil)
}
// NewSuperCommand is like cmd.NewSuperCommand but
// it adds juju-specific functionality:
// - The default logging configuration is taken from the environment;
// - The version is configured to the current juju version;
// - The command emits a log message when a command runs.
func NewSuperCommand(p cmd.SuperCommandParams) *cmd.SuperCommand {
p.Log = &cmd.Log{
DefaultConfig: os.Getenv(osenv.JujuLoggingConfigEnvKey),
}
current := version.Binary{
Number: version.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
// p.Version should be a version.Binary, but juju/cmd does not
// import juju/juju/version so this cannot happen. We have
// tests to assert that this string value is correct.
p.Version = current.String()
p.NotifyRun = runNotifier
return cmd.NewSuperCommand(p)
}
func (s *UpgradeJujuSuite) checkToolsUploaded(c *gc.C, vers version.Binary, agentVersion version.Number) {
storage, err := s.State.ToolsStorage()
c.Assert(err, jc.ErrorIsNil)
defer storage.Close()
_, r, err := storage.Tools(vers)
if !c.Check(err, jc.ErrorIsNil) {
return
}
data, err := ioutil.ReadAll(r)
r.Close()
c.Check(err, jc.ErrorIsNil)
expectContent := version.Binary{
Number: agentVersion,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
checkToolsContent(c, data, "jujud contents "+expectContent.String())
}
// StorageName returns the name that is used to store and retrieve the
// given version of the juju tools.
func StorageName(vers version.Binary) string {
return toolPrefix + vers.String() + toolSuffix
}
// ToolsURL returns a tools URL pointing the API server
// specified by the "serverRoot".
func ToolsURL(serverRoot string, v version.Binary) string {
return fmt.Sprintf("%s/tools/%s", serverRoot, v.String())
}
func makeFakeTools(vers version.Binary) ([]byte, string) {
return coretesting.TarGz(
coretesting.NewTarFile(names.Jujud, 0777, "jujud contents "+vers.String()))
}
// StorageName returns the name that is used to store and retrieve the
// given version of the juju tools.
func StorageName(vers version.Binary, stream string) string {
return storagePrefix(stream) + vers.String() + toolSuffix
}
// SharedToolsDir returns the directory that is used to
// store binaries for the given version of the juju tools
// within the dataDir directory.
func SharedToolsDir(dataDir string, vers version.Binary) string {
return path.Join(dataDir, "tools", vers.String())
}
