// validateUploadAllowed returns an error if an attempt to upload tools should
// not be allowed.
func validateUploadAllowed(env environs.Environ, toolsArch *string, forceVersion bool) error {
if !forceVersion {
// First, check that there isn't already an agent version specified.
if _, hasAgentVersion := env.Config().AgentVersion(); hasAgentVersion {
return fmt.Errorf(noToolsNoUploadMessage)
}
}
// Now check that the architecture for which we are setting up an
// environment matches that from which we are bootstrapping.
hostArch := arch.HostArch()
// We can't build tools for a different architecture if one is specified.
if toolsArch != nil && *toolsArch != hostArch {
return fmt.Errorf("cannot build tools for %q using a machine running on %q", *toolsArch, hostArch)
}
// If no architecture is specified, ensure the target provider supports instances matching our architecture.
supportedArchitectures, err := env.SupportedArchitectures()
if err != nil {
return fmt.Errorf(
"no packaged tools available and cannot determine environment's supported architectures: %v", err)
}
archSupported := false
for _, arch := range supportedArchitectures {
if hostArch == arch {
archSupported = true
break
}
}
if !archSupported {
envType := env.Config().Type()
return fmt.Errorf(
"environment %q of type %s does not support instances running on %q", env.Name(), envType, hostArch)
}
return nil
}
func (s *localJujuTestSuite) TestConstraintsValidator(c *gc.C) {
ctx := coretesting.Context(c)
env, err := local.Provider.Prepare(ctx, minimalConfig(c))
c.Assert(err, gc.IsNil)
validator, err := env.ConstraintsValidator()
c.Assert(err, gc.IsNil)
hostArch := arch.HostArch()
cons := constraints.MustParse(fmt.Sprintf("arch=%s instance-type=foo tags=bar cpu-power=10 cpu-cores=2", hostArch))
unsupported, err := validator.Validate(cons)
c.Assert(err, gc.IsNil)
c.Assert(unsupported, gc.DeepEquals, []string{"cpu-cores", "cpu-power", "instance-type", "tags"})
}
// preferredSpec will if possible return a spec with arch matching that
// of the host machine.
func preferredSpec(specs []*InstanceSpec) *InstanceSpec {
if len(specs) > 1 {
hostArch := arch.HostArch()
for _, spec := range specs {
if spec.Image.Arch == hostArch {
return spec
}
}
}
if len(specs) > 0 {
return specs[0]
}
return nil
}
func (s *localJujuTestSuite) TestConstraintsValidatorVocab(c *gc.C) {
env := s.Prepare(c)
validator, err := env.ConstraintsValidator()
c.Assert(err, gc.IsNil)
hostArch := arch.HostArch()
var invalidArch string
for _, a := range arch.AllSupportedArches {
if a != hostArch {
invalidArch = a
break
}
}
cons := constraints.MustParse(fmt.Sprintf("arch=%s", invalidArch))
_, err = validator.Validate(cons)
c.Assert(err, gc.ErrorMatches, "invalid constraint value: arch="+invalidArch+"\nvalid values are:.*")
}
// The presence and format of this constant is very important.
// The debian/rules build recipe uses this value for the version
// number of the release package.
const version = "1.19.3"
// lsbReleaseFile is the name of the file that is read in order to determine
// the release version of ubuntu.
var lsbReleaseFile = "/etc/lsb-release"
// Current gives the current version of the system. If the file
// "FORCE-VERSION" is present in the same directory as the running
// binary, it will override this.
var Current = Binary{
Number: MustParse(version),
Series: osVersion(),
Arch: arch.HostArch(),
}
func init() {
toolsDir := filepath.Dir(os.Args[0])
v, err := ioutil.ReadFile(filepath.Join(toolsDir, "FORCE-VERSION"))
if err != nil {
if !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "WARNING: cannot read forced version: %v\n", err)
}
return
}
Current.Number = MustParse(strings.TrimSpace(string(v)))
}
// Number represents a juju version. When bugs are fixed the patch
func (s *archSuite) TestHostArch(c *gc.C) {
a := arch.HostArch()
c.Assert(arch.IsSupportedArch(a), jc.IsTrue)
}
