func (s *providerSuite) TestNullAlias(c *gc.C) {
p, err := environs.Provider("manual")
c.Assert(p, gc.NotNil)
c.Assert(err, jc.ErrorIsNil)
p, err = environs.Provider("null")
c.Assert(p, gc.NotNil)
c.Assert(err, jc.ErrorIsNil)
}
// finalizeConfig creates the config object from attributes, calls
// PrepareForCreateEnvironment, and then finally validates the config
// before returning it.
func finalizeConfig(isAdmin bool, controllerCfg *config.Config, attrs map[string]interface{}) (*config.Config, error) {
provider, err := environs.Provider(controllerCfg.Type())
if err != nil {
return nil, errors.Trace(err)
}
// Controller admins creating models do not have to re-supply new secrets.
// These may be copied from the controller model if not supplied.
if isAdmin {
maybeCopyControllerSecrets(provider, controllerCfg.AllAttrs(), attrs)
}
cfg, err := config.New(config.UseDefaults, attrs)
if err != nil {
return nil, errors.Annotate(err, "creating config from values failed")
}
cfg, err = provider.PrepareForCreateEnvironment(cfg)
if err != nil {
return nil, errors.Trace(err)
}
cfg, err = provider.Validate(cfg, nil)
if err != nil {
return nil, errors.Annotate(err, "provider validation failed")
}
return cfg, nil
}
func init() {
dummyProvider, err := environs.Provider("dummy")
if err != nil {
panic(err)
}
environs.RegisterProvider("fake", mockProvider{dummyProvider})
}
func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) {
provider, err := environs.Provider(s.envcfg.Type())
c.Assert(err, gc.IsNil)
env, err := provider.Open(s.envcfg)
c.Assert(err, gc.IsNil)
oldMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
_, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.b64yamlEnvcfg, "--instance-id", string(s.instanceId))
c.Assert(err, gc.IsNil)
err = cmd.Run(nil)
c.Assert(err, gc.IsNil)
newMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
if !exploded {
c.Assert(newMetadata, gc.HasLen, len(oldMetadata))
} else {
// new metadata should have more tools.
c.Assert(len(newMetadata), jc.GreaterThan, len(oldMetadata))
var expectedSeries set.Strings
for _, series := range version.SupportedSeries() {
os, err := version.GetOSFromSeries(series)
c.Assert(err, gc.IsNil)
if os == version.Ubuntu {
expectedSeries.Add(series)
}
}
c.Assert(newMetadata, gc.HasLen, expectedSeries.Size())
for _, m := range newMetadata {
c.Assert(expectedSeries.Contains(m.Release), jc.IsTrue)
}
}
}
func (c *imageMetadataCommandBase) prepare(context *cmd.Context) (environs.Environ, error) {
// NOTE(axw) this is a work-around for the TODO below. This
// means that the command will only work if you've bootstrapped
// the specified environment.
bootstrapConfig, params, err := modelcmd.NewGetBootstrapConfigParamsFunc(context, c.ClientStore())(c.ControllerName())
if err != nil {
return nil, errors.Trace(err)
}
provider, err := environs.Provider(bootstrapConfig.CloudType)
if err != nil {
return nil, errors.Trace(err)
}
cfg, err := provider.PrepareConfig(*params)
if err != nil {
return nil, errors.Trace(err)
}
// TODO(axw) we'll need to revise the metadata commands to work
// without preparing an environment. They should take the same
// format as bootstrap, i.e. cloud/region, and we'll use that to
// identify region and endpoint info that we need. Not sure what
// we'll do about simplestreams.MetadataValidator yet. Probably
// move it to the EnvironProvider interface.
return environs.New(environs.OpenParams{
Cloud: params.Cloud,
Config: cfg,
})
}
func (s *credentialsSuite) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
var err error
s.provider, err = environs.Provider("gce")
c.Assert(err, jc.ErrorIsNil)
}
func (s *MainSuite) TestProvidersAreRegistered(c *gc.C) {
// check that all the expected providers are registered
for _, name := range expectedProviders {
_, err := environs.Provider(name)
c.Assert(err, jc.ErrorIsNil)
}
}
func (s *providerSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
var err error
s.provider, err = environs.Provider("gce")
c.Check(err, jc.ErrorIsNil)
}
func (s *BootstrapSuite) TestAutoSyncLocalSource(c *gc.C) {
sourceDir := createToolsSource(c, vAll)
s.PatchValue(&jujuversion.Current, version.MustParse("1.2.0"))
series.SetLatestLtsForTesting("trusty")
resetJujuXDGDataHome(c)
// Bootstrap the controller with the valid source.
// The bootstrapping has to show no error, because the tools
// are automatically synchronized.
_, err := coretesting.RunCommand(
c, s.newBootstrapCommand(), "--metadata-source", sourceDir,
"devcontroller", "dummy-cloud/region-1",
)
c.Assert(err, jc.ErrorIsNil)
p, err := environs.Provider("dummy")
c.Assert(err, jc.ErrorIsNil)
cfg, err := modelcmd.NewGetBootstrapConfigFunc(s.store)("devcontroller")
c.Assert(err, jc.ErrorIsNil)
env, err := p.PrepareForBootstrap(envtesting.BootstrapContext(c), cfg)
c.Assert(err, jc.ErrorIsNil)
// Now check the available tools which are the 1.2.0 envtools.
checkTools(c, env, v120All)
}
// ModelConfig returns the current environment's configuration.
func (e *ModelWatcher) ModelConfig() (params.ModelConfigResult, error) {
result := params.ModelConfigResult{}
config, err := e.st.ModelConfig()
if err != nil {
return result, err
}
allAttrs := config.AllAttrs()
if !e.authorizer.AuthModelManager() {
// Mask out any secrets in the environment configuration
// with values of the same type, so it'll pass validation.
//
// TODO(dimitern) 201309-26 bug #1231384
// Delete the code below and mark the bug as fixed,
// once it's live tested on MAAS and 1.16 compatibility
// is dropped.
provider, err := environs.Provider(config.Type())
if err != nil {
return result, err
}
secretAttrs, err := provider.SecretAttrs(config)
for k := range secretAttrs {
allAttrs[k] = "not available"
}
}
result.Config = allAttrs
return result, nil
}
// builtInProviders returns cloud information for those
// providers which are built in to Juju.
func builtInProviders() map[string]jujucloud.Cloud {
builtIn := make(map[string]jujucloud.Cloud)
for _, name := range jujucloud.BuiltInProviderNames {
provider, err := environs.Provider(name)
if err != nil {
// Should never happen but it will on go 1.2
// because lxd provider is not built.
logger.Warningf("cloud %q not available on this platform", name)
continue
}
var regions []jujucloud.Region
if detector, ok := provider.(environs.CloudRegionDetector); ok {
regions, err = detector.DetectRegions()
if err != nil && !errors.IsNotFound(err) {
logger.Warningf("could not detect regions for %q: %v", name, err)
}
}
cloud := jujucloud.Cloud{
Type: name,
Regions: regions,
}
schema := provider.CredentialSchemas()
for authType := range schema {
if authType == jujucloud.EmptyAuthType {
continue
}
cloud.AuthTypes = append(cloud.AuthTypes, authType)
}
builtIn[name] = cloud
}
return builtIn
}
func (s *providerSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
provider, err := environs.Provider("lxd")
c.Assert(err, jc.ErrorIsNil)
s.provider = provider
}
func (s *BootstrapSuite) makeTestEnv(c *gc.C) {
attrs := dummy.SampleConfig().Merge(
testing.Attrs{
"agent-version": version.Current.Number.String(),
"bootstrap-timeout": "123",
},
).Delete("admin-secret", "ca-private-key")
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
provider, err := environs.Provider(cfg.Type())
c.Assert(err, jc.ErrorIsNil)
env, err := provider.PrepareForBootstrap(nullContext(), cfg)
c.Assert(err, jc.ErrorIsNil)
envtesting.MustUploadFakeTools(s.toolsStorage, cfg.AgentStream(), cfg.AgentStream())
inst, _, _, err := jujutesting.StartInstance(env, "0")
c.Assert(err, jc.ErrorIsNil)
s.instanceId = inst.Id()
addresses, err := inst.Addresses()
c.Assert(err, jc.ErrorIsNil)
s.bootstrapName = network.SelectPublicAddress(addresses)
s.envcfg = env.Config()
s.b64yamlEnvcfg = b64yaml(s.envcfg.AllAttrs()).encode()
}
func (s *credentialsSuite) SetUpTest(c *gc.C) {
s.FakeHomeSuite.SetUpTest(c)
var err error
s.provider, err = environs.Provider("maas")
c.Assert(err, jc.ErrorIsNil)
}
func (s *providerSuite) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
provider, err := environs.Provider("joyent")
c.Assert(err, jc.ErrorIsNil)
s.provider = provider
s.spec = fakeCloudSpec()
}
func (s *providerSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
var err error
s.provider, err = environs.Provider("vsphere")
c.Check(err, jc.ErrorIsNil)
s.spec = vsphere.FakeCloudSpec()
}
func init() {
dummyProvider, err := environs.Provider("dummy")
if err != nil {
panic(err)
}
environs.RegisterProvider("no-cloud-region-detection", noCloudRegionDetectionProvider{})
environs.RegisterProvider("no-cloud-regions", noCloudRegionsProvider{dummyProvider})
environs.RegisterProvider("no-credentials", noCredentialsProvider{})
environs.RegisterProvider("many-credentials", manyCredentialsProvider{})
}
// RestrictedProviderFields returns the set of config fields that may not be
// overridden.
func RestrictedProviderFields(providerType string) ([]string, error) {
provider, err := environs.Provider(providerType)
if err != nil {
return nil, errors.Trace(err)
}
var fields []string
fields = append(fields, configValuesFromController...)
fields = append(fields, provider.RestrictedConfigAttributes()...)
return fields, nil
}
func (c *validateImageMetadataCommand) createLookupParams(context *cmd.Context) (*simplestreams.MetadataLookupParams, error) {
params := &simplestreams.MetadataLookupParams{Stream: c.stream}
if c.providerType == "" {
environ, err := c.prepare(context)
if err != nil {
return nil, err
}
mdLookup, ok := environ.(simplestreams.MetadataValidator)
if !ok {
return nil, fmt.Errorf("%s provider does not support image metadata validation", environ.Config().Type())
}
params, err = mdLookup.MetadataLookupParams(c.region)
if err != nil {
return nil, err
}
oes := &overrideEnvStream{environ, c.stream}
params.Sources, err = environs.ImageMetadataSources(oes)
if err != nil {
return nil, err
}
} else {
prov, err := environs.Provider(c.providerType)
if err != nil {
return nil, err
}
mdLookup, ok := prov.(simplestreams.MetadataValidator)
if !ok {
return nil, fmt.Errorf("%s provider does not support image metadata validation", c.providerType)
}
params, err = mdLookup.MetadataLookupParams(c.region)
if err != nil {
return nil, err
}
}
if c.series != "" {
params.Series = c.series
}
if c.region != "" {
params.Region = c.region
}
if c.endpoint != "" {
params.Endpoint = c.endpoint
}
if c.metadataDir != "" {
dir := filepath.Join(c.metadataDir, "images")
if _, err := os.Stat(dir); err != nil {
return nil, err
}
params.Sources = imagesDataSources(dir)
}
return params, nil
}
func (em *EnvironmentManagerAPI) restrictedProviderFields(providerType string) ([]string, error) {
provider, err := environs.Provider(providerType)
if err != nil {
return nil, errors.Trace(err)
}
var fields []string
fields = append(fields, configValuesFromStateServer...)
fields = append(fields, provider.RestrictedConfigAttributes()...)
return fields, nil
}
func (g bootstrapConfigGetter) getBootstrapConfig(controllerName string) (*config.Config, error) {
bootstrapConfig, params, err := g.getBootstrapConfigParams(controllerName)
if err != nil {
return nil, errors.Trace(err)
}
provider, err := environs.Provider(bootstrapConfig.CloudType)
if err != nil {
return nil, errors.Trace(err)
}
return provider.PrepareConfig(*params)
}
func (s *ProviderFunctionalSuite) SetUpTest(c *gc.C) {
if !s.IsRunningLocally(c) {
c.Skip("LXD not running locally")
}
s.BaseSuite.SetUpTest(c)
provider, err := environs.Provider("lxd")
c.Assert(err, jc.ErrorIsNil)
s.provider = provider
}
func environProvider(st *state.State) (environs.EnvironProvider, error) {
model, err := st.Model()
if err != nil {
return nil, errors.Annotate(err, "getting model")
}
cloud, err := st.Cloud(model.Cloud())
if err != nil {
return nil, errors.Annotate(err, "getting cloud")
}
// EnvironProvider implements state.ConfigValidator.
return environs.Provider(cloud.Type)
}
func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) {
provider, err := environs.Provider(s.envcfg.Type())
c.Assert(err, gc.IsNil)
env, err := provider.Open(s.envcfg)
c.Assert(err, gc.IsNil)
envtesting.RemoveFakeToolsMetadata(c, env.Storage())
_, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.b64yamlEnvcfg, "--instance-id", string(s.instanceId))
c.Assert(err, gc.IsNil)
err = cmd.Run(nil)
c.Assert(err, gc.IsNil)
// We don't write metadata at bootstrap anymore.
simplestreamsMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
c.Assert(simplestreamsMetadata, gc.HasLen, 0)
// The tools should have been added to state, and
// exploded into each of the supported series of
// the same operating system if the tools were uploaded.
st, err := state.Open(&mongo.MongoInfo{
Info: mongo.Info{
Addrs: []string{gitjujutesting.MgoServer.Addr()},
CACert: testing.CACert,
},
Password: testPasswordHash(),
}, mongo.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st.Close()
var expectedSeries set.Strings
if exploded {
for _, series := range version.SupportedSeries() {
os, err := version.GetOSFromSeries(series)
c.Assert(err, gc.IsNil)
if os == version.Current.OS {
expectedSeries.Add(series)
}
}
} else {
expectedSeries.Add(version.Current.Series)
}
storage, err := st.ToolsStorage()
c.Assert(err, gc.IsNil)
defer storage.Close()
metadata, err := storage.AllMetadata()
c.Assert(err, gc.IsNil)
c.Assert(metadata, gc.HasLen, expectedSeries.Size())
for _, m := range metadata {
c.Assert(expectedSeries.Contains(m.Version.Series), jc.IsTrue)
}
}
func (c *addCredentialCommand) Run(ctxt *cmd.Context) error {
// Check that the supplied cloud is valid.
var err error
if c.cloud, err = common.CloudOrProvider(c.CloudName, c.cloudByNameFunc); err != nil {
if !errors.IsNotFound(err) {
return err
}
}
if len(c.cloud.AuthTypes) == 0 {
return errors.Errorf("cloud %q does not require credentials", c.CloudName)
}
if c.CredentialsFile == "" {
credentialsProvider, err := environs.Provider(c.cloud.Type)
if err != nil {
return errors.Annotate(err, "getting provider for cloud")
}
return c.interactiveAddCredential(ctxt, credentialsProvider.CredentialSchemas())
}
data, err := ioutil.ReadFile(c.CredentialsFile)
if err != nil {
return errors.Annotate(err, "reading credentials file")
}
specifiedCredentials, err := jujucloud.ParseCredentials(data)
if err != nil {
return errors.Annotate(err, "parsing credentials file")
}
credentials, ok := specifiedCredentials[c.CloudName]
if !ok {
return errors.Errorf("no credentials for cloud %s exist in file %s", c.CloudName, c.CredentialsFile)
}
existingCredentials, err := c.existingCredentialsForCloud()
if err != nil {
return errors.Trace(err)
}
// If there are *any* credentials already for the cloud, we'll ask for the --replace flag.
if !c.Replace && len(existingCredentials.AuthCredentials) > 0 && len(credentials.AuthCredentials) > 0 {
return errors.Errorf("credentials for cloud %s already exist; use --replace to overwrite / merge", c.CloudName)
}
for name, cred := range credentials.AuthCredentials {
existingCredentials.AuthCredentials[name] = cred
}
err = c.store.UpdateCredential(c.CloudName, *existingCredentials)
if err != nil {
return err
}
fmt.Fprintf(ctxt.Stdout, "credentials updated for cloud %s\n", c.CloudName)
return nil
}
func (c *CreateCommand) getConfigValues(ctx *cmd.Context, serverSkeleton params.EnvironConfig) (map[string]interface{}, error) {
// The reading of the config YAML is done in the Run
// method because the Read method requires the cmd Context
// for the current directory.
fileConfig := make(map[string]interface{})
if c.ConfigFile.Path != "" {
configYAML, err := c.ConfigFile.Read(ctx)
if err != nil {
return nil, err
}
err = yaml.Unmarshal(configYAML, &fileConfig)
if err != nil {
return nil, err
}
}
configValues := make(map[string]interface{})
for key, value := range serverSkeleton {
configValues[key] = value
}
for key, value := range fileConfig {
configValues[key] = value
}
for key, value := range c.ConfValues {
configValues[key] = value
}
configValues["name"] = c.Name
cfg, err := config.New(config.UseDefaults, configValues)
if err != nil {
return nil, errors.Trace(err)
}
provider, err := environs.Provider(cfg.Type())
if err != nil {
return nil, errors.Trace(err)
}
cfg, err = provider.PrepareForCreateEnvironment(cfg)
if err != nil {
return nil, errors.Trace(err)
}
attrs := cfg.AllAttrs()
delete(attrs, "agent-version")
// TODO: allow version to be specified on the command line and add here.
return attrs, nil
}
func (s *ProviderFunctionalSuite) SetUpTest(c *gc.C) {
if !s.IsRunningLocally(c) {
c.Skip("LXD not running locally")
}
// TODO(redir): Remove after wily or in yakkety.
skipIfWily(c)
s.BaseSuite.SetUpTest(c)
provider, err := environs.Provider("lxd")
c.Assert(err, jc.ErrorIsNil)
s.provider = provider
}
func (s *prepareSuite) TestPrepareProxySSH(c *gc.C) {
s.PatchValue(local.DetectAptProxies, func() (proxy.Settings, error) {
return proxy.Settings{}, nil
})
basecfg, err := config.New(config.UseDefaults, map[string]interface{}{
"type": "local",
"name": "test",
})
provider, err := environs.Provider("local")
c.Assert(err, gc.IsNil)
env, err := provider.Prepare(coretesting.Context(c), basecfg)
c.Assert(err, gc.IsNil)
// local provider sets proxy-ssh to false
c.Assert(env.Config().ProxySSH(), gc.Equals, false)
}
func (em *EnvironmentManagerAPI) validConfig(attrs map[string]interface{}) (*config.Config, error) {
cfg, err := config.New(config.UseDefaults, attrs)
if err != nil {
return nil, errors.Annotate(err, "creating config from values failed")
}
provider, err := environs.Provider(cfg.Type())
if err != nil {
return nil, errors.Trace(err)
}
cfg, err = provider.Validate(cfg, nil)
if err != nil {
return nil, errors.Annotate(err, "provider validation failed")
}
return cfg, nil
}
// BuiltInClouds returns cloud information for those
// providers which are built in to Juju.
func BuiltInClouds() map[string]cloud.Cloud {
// TODO (anastasiamac 2016-04-14)
// This whole method will be redundant after we move to 1.3+.
builtIn := make(map[string]cloud.Cloud)
for name, aCloud := range cloud.BuiltInClouds {
_, err := environs.Provider(aCloud.Type)
if err != nil {
// Should never happen but it will on go 1.2
// because lxd provider is not built.
logger.Errorf("cloud %q not available on this platform", name)
continue
}
builtIn[name] = aCloud
}
return builtIn
}