func (ctxt *Context) ModelDialer(controller, model string) (*Dialer, error) { if controller == "" { c, err := ctxt.store.origStore.CurrentController() if err != nil { return nil, errors.Annotatef(err, "cannot get current controller") } controller = c } if model == "" { m, err := ctxt.store.origStore.CurrentModel(controller) if err != nil { return nil, errors.Annotatef(err, "cannot get current model") } model = m } modelUUID := model if !utils.IsValidUUIDString(model) { md, err := ctxt.store.origStore.ModelByName(controller, model) if err != nil { return nil, errors.Annotatef(err, "cannot get model") } modelUUID = md.ModelUUID } return ctxt.dialer(controller, modelUUID) }
// Validate ensures that config is a valid configuration. func Validate(c Config) error { if v, ok := c[IdentityURL].(string); ok { u, err := url.Parse(v) if err != nil { return errors.Annotate(err, "invalid identity URL") } if u.Scheme != "https" { return errors.Errorf("URL needs to be https") } } if v, ok := c[IdentityPublicKey].(string); ok { var key bakery.PublicKey if err := key.UnmarshalText([]byte(v)); err != nil { return errors.Annotate(err, "invalid identity public key") } } caCert, caCertOK := c.CACert() if !caCertOK { return errors.Errorf("missing CA certificate") } if _, err := cert.ParseCert(caCert); err != nil { return errors.Annotate(err, "bad CA certificate in configuration") } if uuid, ok := c[ControllerUUIDKey].(string); ok && !utils.IsValidUUIDString(uuid) { return errors.Errorf("controller-uuid: expected UUID, got string(%q)", uuid) } return nil }
func (*uuidSuite) TestIsValidUUIDFailsWhenNotValid(c *gc.C) { tests := []struct { input string expected bool }{ { utils.UUID{}.String(), true, }, { "", false, }, { "blah", false, }, { "blah-9f484882-2f18-4fd2-967d-db9663db7bea", false, }, { "9f484882-2f18-4fd2-967d-db9663db7bea-blah", false, }, { "9f484882-2f18-4fd2-967d-db9663db7bea", true, }, } for i, t := range tests { c.Logf("Running test %d", i) c.Check(utils.IsValidUUIDString(t.input), gc.Equals, t.expected) } }
// Validate ensures that the entry considers itself to be in a // complete and valid state. func (e AuditEntry) Validate() error { if e.JujuServerVersion == version.Zero { return errors.NewNotValid(errors.NotAssignedf("JujuServerVersion"), "") } if e.ModelUUID == "" { return errors.NewNotValid(errors.NotAssignedf("ModelUUID"), "") } if utils.IsValidUUIDString(e.ModelUUID) == false { return errors.NotValidf("ModelUUID") } if e.Timestamp.IsZero() { return errors.NewNotValid(errors.NotAssignedf("Timestamp"), "") } if e.Timestamp.Location() != time.UTC { return errors.NewNotValid(errors.NotValidf("Timestamp"), "must be set to UTC") } if e.RemoteAddress == "" { return errors.NewNotValid(errors.NotAssignedf("RemoteAddress"), "") } if e.OriginType == "" { return errors.NewNotValid(errors.NotAssignedf("OriginType"), "") } if e.OriginName == "" { return errors.NewNotValid(errors.NotAssignedf("OriginName"), "") } if e.Operation == "" { return errors.NewNotValid(errors.NotAssignedf("Operation"), "") } // Data remains unchecked as it is always optional. return nil }
// Validate returns an error if the config cannot be expected to // drive a functional Worker. func (config Config) Validate() error { if config.Facade == nil { return errors.NotValidf("nil Facade") } if !utils.IsValidUUIDString(config.Model) { return errors.NotValidf("Model %q", config.Model) } if config.Check == nil { return errors.NotValidf("nil Check") } return nil }
// FindEntity returns the entity with the given tag. // // The returned value can be of type *Machine, *Unit, // *User, *Service, *Environment, or *Action, depending // on the tag. func (st *State) FindEntity(tag string) (Entity, error) { t, err := names.ParseTag(tag) if err != nil { return nil, err } id := t.Id() switch t.(type) { case names.MachineTag: return st.Machine(id) case names.UnitTag: return st.Unit(id) case names.UserTag: return st.User(id) case names.ServiceTag: return st.Service(id) case names.EnvironTag: env, err := st.Environment() if err != nil { return nil, err } // Return an invalid entity error if the requested environment is not // the current one. if id != env.UUID() { if utils.IsValidUUIDString(id) { return nil, errors.NotFoundf("environment %q", id) } // TODO(axw) 2013-12-04 #1257587 // We should not accept environment tags that do not match the // environment's UUID. We accept anything for now, to cater // both for past usage, and for potentially supporting aliases. logger.Warningf("environment-tag does not match current environment UUID: %q != %q", id, env.UUID()) conf, err := st.EnvironConfig() if err != nil { logger.Warningf("EnvironConfig failed: %v", err) } else if id != conf.Name() { logger.Warningf("environment-tag does not match current environment name: %q != %q", id, conf.Name()) } } return env, nil case names.RelationTag: return st.KeyRelation(id) case names.NetworkTag: return st.Network(id) case names.ActionTag: return st.ActionByTag(t) default: return nil, errors.Errorf("unsupported tag tpe %T", t) } }
func (s *modelmanagerSuite) TestCreateModel(c *gc.C) { modelManager := s.OpenAPI(c) user := s.Factory.MakeUser(c, nil) owner := user.UserTag().Canonical() newEnv, err := modelManager.CreateModel(owner, nil, map[string]interface{}{ "name": "new-model", "authorized-keys": "ssh-key", // dummy needs controller "controller": false, }) c.Assert(err, jc.ErrorIsNil) c.Assert(newEnv.Name, gc.Equals, "new-model") c.Assert(newEnv.OwnerTag, gc.Equals, user.Tag().String()) c.Assert(utils.IsValidUUIDString(newEnv.UUID), jc.IsTrue) }
func (s *environmentmanagerSuite) TestCreateEnvironment(c *gc.C) { envManager := s.OpenAPI(c) user := s.Factory.MakeUser(c, nil) owner := user.UserTag().Canonical() newEnv, err := envManager.CreateEnvironment(owner, nil, map[string]interface{}{ "name": "new-env", "authorized-keys": "ssh-key", // dummy needs state-server "state-server": false, }) c.Assert(err, jc.ErrorIsNil) c.Assert(newEnv.Name, gc.Equals, "new-env") c.Assert(newEnv.OwnerTag, gc.Equals, user.Tag().String()) c.Assert(utils.IsValidUUIDString(newEnv.UUID), jc.IsTrue) }
func (s *modelmanagerSuite) testCreateModel(c *gc.C, cloud, region string) { modelManager := s.OpenAPI(c) defer modelManager.Close() user := s.Factory.MakeUser(c, nil) owner := user.UserTag().Id() newModel, err := modelManager.CreateModel("new-model", owner, cloud, region, names.CloudCredentialTag{}, map[string]interface{}{ "authorized-keys": "ssh-key", // dummy needs controller "controller": false, }) c.Assert(err, jc.ErrorIsNil) c.Assert(newModel.Name, gc.Equals, "new-model") c.Assert(newModel.Owner, gc.Equals, user.String()) c.Assert(newModel.CloudRegion, gc.Equals, "dummy-region") c.Assert(utils.IsValidUUIDString(newModel.UUID), jc.IsTrue) }
// Validate checks the AuthorizationRequest for errors. func (s AuthorizationRequest) Validate() error { if !utils.IsValidUUIDString(s.EnvironmentUUID) { return errors.Errorf("invalid environment UUID: %q", s.EnvironmentUUID) } if s.ServiceName == "" { return errors.New("undefined service name") } if !names.IsValidApplication(s.ServiceName) { return errors.Errorf("invalid service name: %q", s.ServiceName) } if s.CharmURL == "" { return errors.New("undefined charm url") } if !names.IsValidCharm(s.CharmURL) { return errors.Errorf("invalid charm url: %q", s.CharmURL) } if s.PlanURL == "" { return errors.Errorf("undefined plan url") } return nil }
// Init implements cmd.Command.Init. func (c *allocateCommand) Init(args []string) error { if len(args) < 2 { return errors.New("budget and service name required") } budgetWithLimit := args[0] var err error c.Budget, c.Limit, err = parseBudgetWithLimit(budgetWithLimit) if err != nil { return errors.Annotate(err, `expected args in the form "budget:limit [service ...]"`) } if c.ModelUUID == "" { c.ModelUUID, err = c.modelUUID() if err != nil { return err } } else { if !utils.IsValidUUIDString(c.ModelUUID) { return errors.NotValidf("model UUID %q", c.ModelUUID) } } c.Services = args[1:] return nil }
// Validate ensures that config is a valid configuration. func Validate(c Config) error { if v, ok := c[IdentityPublicKey].(string); ok { var key bakery.PublicKey if err := key.UnmarshalText([]byte(v)); err != nil { return errors.Annotate(err, "invalid identity public key") } } if v, ok := c[IdentityURL].(string); ok { u, err := url.Parse(v) if err != nil { return errors.Annotate(err, "invalid identity URL") } // If we've got an identity public key, we allow an HTTP // scheme for the identity server because we won't need // to rely on insecure transport to obtain the public // key. if _, ok := c[IdentityPublicKey]; !ok && u.Scheme != "https" { return errors.Errorf("URL needs to be https when %s not provided", IdentityPublicKey) } } caCert, caCertOK := c.CACert() if !caCertOK { return errors.Errorf("missing CA certificate") } if _, err := cert.ParseCert(caCert); err != nil { return errors.Annotate(err, "bad CA certificate in configuration") } if uuid, ok := c[ControllerUUIDKey].(string); ok && !utils.IsValidUUIDString(uuid) { return errors.Errorf("controller-uuid: expected UUID, got string(%q)", uuid) } return nil }
// resolveNetwork takes either a network id or label and returns a network id func (e *Environ) resolveNetwork(networkName string) (string, error) { if utils.IsValidUUIDString(networkName) { // Network id supplied, assume valid as boot will fail if not return networkName, nil } // Network label supplied, resolve to a network id networks, err := e.nova().ListNetworks() if err != nil { return "", err } var networkIds = []string{} for _, network := range networks { if network.Label == networkName { networkIds = append(networkIds, network.Id) } } switch len(networkIds) { case 1: return networkIds[0], nil case 0: return "", errors.Errorf("No networks exist with label %q", networkName) } return "", errors.Errorf("Multiple networks with label %q: %v", networkName, networkIds) }
// For compatibility with Juju 1.25, UUIDs are also supported. func isValidPayload(id string) bool { return IsValidPayload(id) || utils.IsValidUUIDString(id) }
// IsValidAction returns whether id is a valid action id (UUID). func IsValidAction(id string) bool { return utils.IsValidUUIDString(id) }
func (s *fakeHomeSuite) TestEnvironUUIDValid(c *gc.C) { c.Assert(utils.IsValidUUIDString(testing.ModelTag.Id()), jc.IsTrue) }
func (*uuidSuite) TestIsValidUUIDFailsWhenNotValid(c *gc.C) { c.Assert(utils.IsValidUUIDString("blah"), gc.Equals, false) }
// 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 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 model configuration", attr) } } modelName := cfg.asString(NameKey) if modelName == "" { return errors.New("empty name in model configuration") } if !names.IsValidModelName(modelName) { return fmt.Errorf("%q is not a valid name: model names may only contain lowercase letters, digits and hyphens", modelName) } // Check that the agent version parses ok if set explicitly; otherwise leave // it alone. if v, ok := cfg.defined[AgentVersionKey].(string); ok { if _, err := version.Parse(v); err != nil { return fmt.Errorf("invalid agent version in model 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.ParseConfigString(v); err != nil { return err } } if lfCfg, ok := cfg.LogFwdSyslog(); ok { if err := lfCfg.Validate(); err != nil { return errors.Annotate(err, "invalid syslog forwarding config") } } if uuid := cfg.UUID(); !utils.IsValidUUIDString(uuid) { return errors.Errorf("uuid: expected UUID, got string(%q)", uuid) } // Ensure the resource tags have the expected k=v format. if _, err := cfg.resourceTags(); err != nil { return errors.Annotate(err, "validating resource tags") } // Check the immutable config values. These can't change if old != nil { for _, attr := range immutableAttributes { oldv, ok := old.defined[attr] if !ok { continue } if newv := cfg.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 errors.New("cannot clear agent-version") } } } cfg.defined = ProcessDeprecatedAttributes(cfg.defined) return nil }
func (s *BootstrapSuite) run(c *gc.C, test bootstrapTest) testing.Restorer { // Create home with dummy provider and remove all // of its envtools. resetJujuXDGDataHome(c) dummy.Reset(c) var restore testing.Restorer = func() { s.store = jujuclienttesting.NewMemStore() } if test.version != "" { useVersion := strings.Replace(test.version, "%LTS%", series.LatestLts(), 1) v := version.MustParseBinary(useVersion) restore = restore.Add(testing.PatchValue(&jujuversion.Current, v.Number)) restore = restore.Add(testing.PatchValue(&arch.HostArch, func() string { return v.Arch })) restore = restore.Add(testing.PatchValue(&series.HostSeries, func() string { return v.Series })) } if test.hostArch != "" { restore = restore.Add(testing.PatchValue(&arch.HostArch, func() string { return test.hostArch })) } controllerName := "peckham-controller" cloudName := "dummy" // Run command and check for uploads. args := append([]string{ controllerName, cloudName, "--config", "default-series=raring", }, test.args...) opc, errc := cmdtesting.RunCommand(cmdtesting.NullContext(c), s.newBootstrapCommand(), args...) // Check for remaining operations/errors. if test.err != "" { err := <-errc c.Assert(err, gc.NotNil) stripped := strings.Replace(err.Error(), "\n", "", -1) c.Check(stripped, gc.Matches, test.err) return restore } if !c.Check(<-errc, gc.IsNil) { return restore } opBootstrap := (<-opc).(dummy.OpBootstrap) c.Check(opBootstrap.Env, gc.Equals, "admin") c.Check(opBootstrap.Args.ModelConstraints, gc.DeepEquals, test.constraints) if test.bootstrapConstraints == (constraints.Value{}) { test.bootstrapConstraints = test.constraints } c.Check(opBootstrap.Args.BootstrapConstraints, gc.DeepEquals, test.bootstrapConstraints) c.Check(opBootstrap.Args.Placement, gc.Equals, test.placement) opFinalizeBootstrap := (<-opc).(dummy.OpFinalizeBootstrap) c.Check(opFinalizeBootstrap.Env, gc.Equals, "admin") c.Check(opFinalizeBootstrap.InstanceConfig.ToolsList(), gc.Not(gc.HasLen), 0) if test.upload != "" { c.Check(opFinalizeBootstrap.InstanceConfig.AgentVersion().String(), gc.Equals, test.upload) } expectedBootstrappedControllerName := bootstrappedControllerName(controllerName) // Check controllers.yaml controller details. addrConnectedTo := []string{"localhost:17070"} controller, err := s.store.ControllerByName(expectedBootstrappedControllerName) c.Assert(err, jc.ErrorIsNil) c.Assert(controller.CACert, gc.Not(gc.Equals), "") c.Assert(controller.UnresolvedAPIEndpoints, gc.DeepEquals, addrConnectedTo) c.Assert(controller.APIEndpoints, gc.DeepEquals, addrConnectedTo) c.Assert(utils.IsValidUUIDString(controller.ControllerUUID), jc.IsTrue) // Controller model should be called "admin". controllerModel, err := s.store.ModelByName(expectedBootstrappedControllerName, "admin@local", "admin") c.Assert(controllerModel.ModelUUID, gc.Equals, controller.ControllerUUID) c.Assert(err, jc.ErrorIsNil) // Bootstrap config should have been saved, and should only contain // the type, name, and any user-supplied configuration. bootstrapConfig, err := s.store.BootstrapConfigForController(expectedBootstrappedControllerName) c.Assert(err, jc.ErrorIsNil) c.Assert(bootstrapConfig.Cloud, gc.Equals, "dummy") c.Assert(bootstrapConfig.Credential, gc.Equals, "") c.Assert(bootstrapConfig.Config, jc.DeepEquals, map[string]interface{}{ "name": "admin", "type": "dummy", "default-series": "raring", }) return restore }
// IsValidIPAddress returns whether id is a valid IP address ID. // Here it simply is checked if it is a valid UUID. func IsValidIPAddress(id string) bool { return utils.IsValidUUIDString(id) }