// 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) }