func (*suite) TestCompare(c *gc.C) {
for i, test := range cmpTests {
c.Logf("test %d", i)
v1, err := version.Parse(test.v1)
c.Assert(err, gc.IsNil)
v2, err := version.Parse(test.v2)
c.Assert(err, gc.IsNil)
compare := v1.Compare(v2)
c.Check(compare, gc.Equals, test.compare)
// Check that reversing the operands has
// the expected result.
compare = v2.Compare(v1)
c.Check(compare, gc.Equals, -test.compare)
}
}
func (c *UpgradeJujuCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if c.vers != "" {
vers, err := version.Parse(c.vers)
if err != nil {
return err
}
if vers.Major != version.Current.Major {
return fmt.Errorf("cannot upgrade to version incompatible with CLI")
}
if c.UploadTools && vers.Build != 0 {
// TODO(fwereade): when we start taking versions from actual built
// code, we should disable --version when used with --upload-tools.
// For now, it's the only way to experiment with version upgrade
// behaviour live, so the only restriction is that Build cannot
// be used (because its value needs to be chosen internally so as
// not to collide with existing tools).
return fmt.Errorf("cannot specify build number when uploading tools")
}
c.Version = vers
}
if len(c.Series) > 0 && !c.UploadTools {
return fmt.Errorf("--series requires --upload-tools")
}
return cmd.CheckEmpty(args)
}
// AgentVersion returns the proposed version number for the agent tools,
// and whether it has been set. Once an environment is bootstrapped, this
// must always be valid.
func (c *Config) AgentVersion() (version.Number, bool) {
if v, ok := c.defined["agent-version"].(string); ok {
n, err := version.Parse(v)
if err != nil {
panic(err) // We should have checked it earlier.
}
return n, true
}
return version.Zero, false
}
// 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, false, simplestreams.LookupParams{
CloudSpec: simplestreams.CloudSpec{
Region: params.Region,
Endpoint: params.Endpoint,
},
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,
},
Series: []string{params.Series},
Arches: params.Architectures,
})
}
matchingTools, resolveInfo, err := Fetch(params.Sources, simplestreams.DefaultIndexPath, 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 (*suite) TestParse(c *gc.C) {
for i, test := range parseTests {
c.Logf("test %d", i)
got, err := version.Parse(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)
c.Check(got.IsDev(), gc.Equals, test.dev)
c.Check(got.String(), gc.Equals, test.v)
}
}
}
// Validate ensures that config is a valid configuration. If old is not nil,
// it holds the previous environment configuration for consideration when
// validating changes.
func Validate(cfg, old *Config) error {
// Check that we don't have any disallowed fields.
for _, attr := range allowedWithDefaultsOnly {
if _, ok := cfg.defined[attr]; ok {
return fmt.Errorf("attribute %q is not allowed in configuration", attr)
}
}
// Check that mandatory fields are specified.
for _, attr := range mandatoryWithoutDefaults {
if _, ok := cfg.defined[attr]; !ok {
return fmt.Errorf("%s missing from environment configuration", attr)
}
}
// Check that all other fields that have been specified are non-empty,
// unless they're allowed to be empty for backward compatibility,
for attr, val := range cfg.defined {
if !isEmpty(val) {
continue
}
if !allowEmpty(attr) {
return fmt.Errorf("empty %s in environment configuration", attr)
}
}
if strings.ContainsAny(cfg.mustString("name"), "/\\") {
return fmt.Errorf("environment name contains unsafe characters")
}
// Check that the agent version parses ok if set explicitly; otherwise leave
// it alone.
if v, ok := cfg.defined["agent-version"].(string); ok {
if _, err := version.Parse(v); err != nil {
return fmt.Errorf("invalid agent version in environment configuration: %q", v)
}
}
// If the logging config is set, make sure it is valid.
if v, ok := cfg.defined["logging-config"].(string); ok {
if _, err := loggo.ParseConfigurationString(v); err != nil {
return err
}
}
// Check firewall mode.
if mode := cfg.FirewallMode(); mode != FwInstance && mode != FwGlobal {
return fmt.Errorf("invalid firewall mode in environment configuration: %q", mode)
}
caCert, caCertOK := cfg.CACert()
caKey, caKeyOK := cfg.CAPrivateKey()
if caCertOK || caKeyOK {
if err := verifyKeyPair(caCert, caKey); err != nil {
return errgo.Annotate(err, "bad CA certificate/key in configuration")
}
}
// Ensure that the auth token is a set of key=value pairs.
authToken, _ := cfg.CharmStoreAuth()
validAuthToken := regexp.MustCompile(`^([^\s=]+=[^\s=]+(,\s*)?)*$`)
if !validAuthToken.MatchString(authToken) {
return fmt.Errorf("charm store auth token needs to be a set"+
" of key-value pairs, not %q", authToken)
}
// Check the immutable config values. These can't change
if old != nil {
for _, attr := range immutableAttributes {
if newv, oldv := cfg.defined[attr], old.defined[attr]; newv != oldv {
return fmt.Errorf("cannot change %s from %#v to %#v", attr, oldv, newv)
}
}
if _, oldFound := old.AgentVersion(); oldFound {
if _, newFound := cfg.AgentVersion(); !newFound {
return fmt.Errorf("cannot clear agent-version")
}
}
}
cfg.processDeprecatedAttributes()
return nil
}
