func (s *bootstrapSuite) TestBootstrapNeedsSettings(c *gc.C) {
env := newEnviron("bar", noKeysDefined, nil)
s.setDummyStorage(c, env)
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
CAPrivateKey: coretesting.CAKey,
})
c.Assert(err, gc.ErrorMatches, "validating bootstrap parameters: admin-secret is empty")
controllerCfg := coretesting.FakeControllerConfig()
delete(controllerCfg, "ca-cert")
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
ControllerConfig: controllerCfg,
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
})
c.Assert(err, gc.ErrorMatches, "validating bootstrap parameters: controller configuration has no ca-cert")
controllerCfg = coretesting.FakeControllerConfig()
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
ControllerConfig: controllerCfg,
AdminSecret: "admin-secret",
})
c.Assert(err, gc.ErrorMatches, "validating bootstrap parameters: empty ca-private-key")
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
ControllerConfig: controllerCfg,
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
})
c.Assert(err, jc.ErrorIsNil)
}
func (s *suite) bootstrapTestEnviron(c *gc.C) environs.NetworkingEnviron {
env, err := bootstrap.Prepare(
envtesting.BootstrapContext(c),
s.ControllerStore,
bootstrap.PrepareParams{
ControllerConfig: testing.FakeControllerConfig(),
ModelConfig: s.TestConfig,
ControllerName: s.TestConfig["name"].(string),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: AdminSecret,
},
)
c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", s.TestConfig))
c.Assert(env, gc.NotNil)
netenv, supported := environs.SupportsNetworking(env)
c.Assert(supported, jc.IsTrue)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), netenv, bootstrap.BootstrapParams{
ControllerConfig: testing.FakeControllerConfig(),
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
},
AdminSecret: AdminSecret,
CAPrivateKey: testing.CAKey,
})
c.Assert(err, jc.ErrorIsNil)
return netenv
}
func (s *BootstrapSuite) TestCannotStartInstance(c *gc.C) {
s.PatchValue(&jujuversion.Current, coretesting.FakeVersionNumber)
checkPlacement := "directive"
checkCons := constraints.MustParse("mem=8G")
env := &mockEnviron{
storage: newStorage(s, c),
config: configGetter(c),
}
startInstance := func(
placement string,
cons constraints.Value,
_ []string,
possibleTools tools.List,
icfg *instancecfg.InstanceConfig,
) (instance.Instance, *instance.HardwareCharacteristics, []network.InterfaceInfo, error) {
c.Assert(placement, gc.DeepEquals, checkPlacement)
c.Assert(cons, gc.DeepEquals, checkCons)
// The machine config should set its upgrade behavior based on
// the environment config.
expectedMcfg, err := instancecfg.NewBootstrapInstanceConfig(coretesting.FakeControllerConfig(), cons, cons, icfg.Series, "")
c.Assert(err, jc.ErrorIsNil)
expectedMcfg.EnableOSRefreshUpdate = env.Config().EnableOSRefreshUpdate()
expectedMcfg.EnableOSUpgrade = env.Config().EnableOSUpgrade()
expectedMcfg.Tags = map[string]string{
"juju-model-uuid": coretesting.ModelTag.Id(),
"juju-controller-uuid": coretesting.ControllerTag.Id(),
"juju-is-controller": "true",
}
c.Assert(icfg, jc.DeepEquals, expectedMcfg)
return nil, nil, nil, errors.Errorf("meh, not started")
}
env.startInstance = startInstance
ctx := envtesting.BootstrapContext(c)
_, err := common.Bootstrap(ctx, env, environs.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
BootstrapConstraints: checkCons,
ModelConstraints: checkCons,
Placement: checkPlacement,
AvailableTools: tools.List{
&tools.Tools{
Version: version.Binary{
Number: jujuversion.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
},
},
}})
c.Assert(err, gc.ErrorMatches, "cannot start bootstrap instance: meh, not started")
}
func (s *bootstrapSuite) TestBootstrapEmptyConstraints(c *gc.C) {
env := newEnviron("foo", useDefaultKeys, nil)
s.setDummyStorage(c, env)
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.bootstrapCount, gc.Equals, 1)
env.args.AvailableTools = nil
c.Assert(env.args, gc.DeepEquals, environs.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
})
}
func (t *LiveTests) bootstrapParams() bootstrap.BootstrapParams {
credential := t.Credential
if credential.AuthType() == "" {
credential = cloud.NewEmptyCredential()
}
var regions []cloud.Region
if t.CloudRegion != "" {
regions = []cloud.Region{{
Name: t.CloudRegion,
Endpoint: t.CloudEndpoint,
}}
}
return bootstrap.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
CloudName: t.TestConfig["type"].(string),
Cloud: cloud.Cloud{
Type: t.TestConfig["type"].(string),
AuthTypes: []cloud.AuthType{credential.AuthType()},
Regions: regions,
Endpoint: t.CloudEndpoint,
},
CloudRegion: t.CloudRegion,
CloudCredential: &credential,
CloudCredentialName: "credential",
AdminSecret: AdminSecret,
CAPrivateKey: coretesting.CAKey,
}
}
func (s *environSuite) TestBootstrapOpensAPIPort(c *gc.C) {
finalizer := func(environs.BootstrapContext, *instancecfg.InstanceConfig, environs.BootstrapDialOpts) error {
return nil
}
s.FakeCommon.BSFinalizer = finalizer
ctx := envtesting.BootstrapContext(c)
params := environs.BootstrapParams{
ControllerConfig: testing.FakeControllerConfig(),
}
_, err := s.Env.Bootstrap(ctx, params)
c.Assert(err, jc.ErrorIsNil)
apiPort := params.ControllerConfig.APIPort()
called, calls := s.FakeConn.WasCalled("OpenPorts")
c.Check(called, gc.Equals, true)
c.Check(calls, gc.HasLen, 1)
c.Check(calls[0].FirewallName, gc.Equals, gce.GlobalFirewallName(s.Env))
expectPorts := []network.PortRange{{
FromPort: apiPort,
ToPort: apiPort,
Protocol: "tcp",
}}
c.Check(calls[0].PortRanges, jc.DeepEquals, expectPorts)
}
func (s *ImageMetadataSuite) env(c *gc.C, imageMetadataURL, stream string) environs.Environ {
attrs := dummy.SampleConfig()
if stream != "" {
attrs = attrs.Merge(testing.Attrs{
"image-stream": stream,
})
}
if imageMetadataURL != "" {
attrs = attrs.Merge(testing.Attrs{
"image-metadata-url": imageMetadataURL,
})
}
env, err := bootstrap.Prepare(
envtesting.BootstrapContext(c),
jujuclienttesting.NewMemStore(),
bootstrap.PrepareParams{
ControllerConfig: testing.FakeControllerConfig(),
ControllerName: attrs["name"].(string),
ModelConfig: attrs,
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
},
)
c.Assert(err, jc.ErrorIsNil)
return env
}
func (s *bootstrapSuite) TestBootstrapCloudCredential(c *gc.C) {
env := newEnviron("foo", useDefaultKeys, nil)
s.setDummyStorage(c, env)
credential := cloud.NewCredential(cloud.EmptyAuthType, map[string]string{"what": "ever"})
args := bootstrap.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
Regions: []cloud.Region{{Name: "region-name"}},
},
CloudName: "cloud-name",
CloudRegion: "region-name",
CloudCredentialName: "credential-name",
CloudCredential: &credential,
}
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.bootstrapCount, gc.Equals, 1)
c.Assert(env.instanceConfig, gc.NotNil)
c.Assert(env.instanceConfig.Bootstrap.ControllerCloud, jc.DeepEquals, args.Cloud)
c.Assert(env.instanceConfig.Bootstrap.ControllerCloudName, jc.DeepEquals, args.CloudName)
c.Assert(env.instanceConfig.Bootstrap.ControllerCloudRegion, jc.DeepEquals, args.CloudRegion)
c.Assert(env.instanceConfig.Bootstrap.ControllerCloudCredential, jc.DeepEquals, args.CloudCredential)
c.Assert(env.instanceConfig.Bootstrap.ControllerCloudCredentialName, jc.DeepEquals, args.CloudCredentialName)
}
func (s *bootstrapSuite) TestBootstrapGUISuccessLocal(c *gc.C) {
path := makeGUIArchive(c, "jujugui-2.2.0")
s.PatchEnvironment("JUJU_GUI", path)
env := newEnviron("foo", useDefaultKeys, nil)
ctx := coretesting.Context(c)
err := bootstrap.Bootstrap(modelcmd.BootstrapContext(ctx), env, bootstrap.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(coretesting.Stderr(ctx), jc.Contains, "Fetching Juju GUI 2.2.0 from local archive\n")
// Check GUI URL and version.
c.Assert(env.instanceConfig.Bootstrap.GUI.URL, gc.Equals, "file://"+path)
c.Assert(env.instanceConfig.Bootstrap.GUI.Version.String(), gc.Equals, "2.2.0")
// Check GUI size.
f, err := os.Open(path)
c.Assert(err, jc.ErrorIsNil)
defer f.Close()
info, err := f.Stat()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.instanceConfig.Bootstrap.GUI.Size, gc.Equals, info.Size())
// Check GUI hash.
h := sha256.New()
_, err = io.Copy(h, f)
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.instanceConfig.Bootstrap.GUI.SHA256, gc.Equals, fmt.Sprintf("%x", h.Sum(nil)))
}
func (s *bootstrapSuite) TestBootstrapGUISuccessRemote(c *gc.C) {
s.PatchValue(bootstrap.GUIFetchMetadata, func(stream string, sources ...simplestreams.DataSource) ([]*gui.Metadata, error) {
c.Assert(stream, gc.Equals, gui.ReleasedStream)
c.Assert(sources[0].Description(), gc.Equals, "gui simplestreams")
c.Assert(sources[0].RequireSigned(), jc.IsTrue)
return []*gui.Metadata{{
Version: version.MustParse("2.0.42"),
FullPath: "https://1.2.3.4/juju-gui-2.0.42.tar.bz2",
SHA256: "hash-2.0.42",
Size: 42,
}, {
Version: version.MustParse("2.0.47"),
FullPath: "https://1.2.3.4/juju-gui-2.0.47.tar.bz2",
SHA256: "hash-2.0.47",
Size: 47,
}}, nil
})
env := newEnviron("foo", useDefaultKeys, nil)
ctx := coretesting.Context(c)
err := bootstrap.Bootstrap(modelcmd.BootstrapContext(ctx), env, bootstrap.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
GUIDataSourceBaseURL: "https://1.2.3.4/gui/sources",
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(coretesting.Stderr(ctx), jc.Contains, "Fetching Juju GUI 2.0.42\n")
// The most recent GUI release info has been stored.
c.Assert(env.instanceConfig.Bootstrap.GUI.URL, gc.Equals, "https://1.2.3.4/juju-gui-2.0.42.tar.bz2")
c.Assert(env.instanceConfig.Bootstrap.GUI.Version.String(), gc.Equals, "2.0.42")
c.Assert(env.instanceConfig.Bootstrap.GUI.Size, gc.Equals, int64(42))
c.Assert(env.instanceConfig.Bootstrap.GUI.SHA256, gc.Equals, "hash-2.0.42")
}
func (s *bootstrapSuite) TestBootstrapNoToolsNonReleaseStream(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: Currently does not work because of jujud problems")
}
// Patch out HostArch and FindTools to allow the test to pass on other architectures,
// such as s390.
s.PatchValue(&arch.HostArch, func() string { return arch.ARM64 })
s.PatchValue(bootstrap.FindTools, func(environs.Environ, int, int, string, tools.Filter) (tools.List, error) {
return nil, errors.NotFoundf("tools")
})
env := newEnviron("foo", useDefaultKeys, map[string]interface{}{
"agent-stream": "proposed"})
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
ControllerConfig: coretesting.FakeControllerConfig(),
BuildAgentTarball: func(bool, *version.Number, string) (*sync.BuiltAgent, error) {
return &sync.BuiltAgent{Dir: c.MkDir()}, nil
},
})
// bootstrap.Bootstrap leaves it to the provider to
// locate bootstrap tools.
c.Assert(err, jc.ErrorIsNil)
}
func (s *bootstrapSuite) TestBootstrapBuildAgent(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: Currently does not work because of jujud problems")
}
// Patch out HostArch and FindTools to allow the test to pass on other architectures,
// such as s390.
s.PatchValue(&arch.HostArch, func() string { return arch.ARM64 })
s.PatchValue(bootstrap.FindTools, func(environs.Environ, int, int, string, tools.Filter) (tools.List, error) {
c.Fatal("should not call FindTools if BuildAgent is specified")
return nil, errors.NotFoundf("tools")
})
env := newEnviron("foo", useDefaultKeys, nil)
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
BuildAgent: true,
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
ControllerConfig: coretesting.FakeControllerConfig(),
BuildAgentTarball: func(build bool, ver *version.Number, _ string) (*sync.BuiltAgent, error) {
c.Logf("BuildAgentTarball version %s", ver)
c.Assert(build, jc.IsTrue)
return &sync.BuiltAgent{Dir: c.MkDir()}, nil
},
})
c.Assert(err, jc.ErrorIsNil)
// Check that the model config has the correct version set.
cfg := env.instanceConfig.Bootstrap.ControllerModelConfig
agentVersion, valid := cfg.AgentVersion()
c.Check(valid, jc.IsTrue)
c.Check(agentVersion.String(), gc.Equals, "1.99.0.1")
}
func (s *bootstrapSuite) TestBootstrapLocalToolsDifferentLinuxes(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: Currently does not work because of jujud problems")
}
// Client host is some unspecified Linux system, wanting to
// bootstrap a trusty controller with local tools. This should be
// OK.
s.PatchValue(&jujuos.HostOS, func() jujuos.OSType { return jujuos.GenericLinux })
s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
s.PatchValue(bootstrap.FindTools, func(environs.Environ, int, int, string, tools.Filter) (tools.List, error) {
return nil, errors.NotFoundf("tools")
})
env := newEnviron("foo", useDefaultKeys, nil)
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
ControllerConfig: coretesting.FakeControllerConfig(),
BuildAgentTarball: func(bool, *version.Number, string) (*sync.BuiltAgent, error) {
return &sync.BuiltAgent{Dir: c.MkDir()}, nil
},
BootstrapSeries: "trusty",
})
c.Assert(err, jc.ErrorIsNil)
c.Check(env.bootstrapCount, gc.Equals, 1)
c.Check(env.args.BootstrapSeries, gc.Equals, "trusty")
c.Check(env.args.AvailableTools.AllSeries(), jc.SameContents, []string{"trusty"})
}
func (s *bootstrapSuite) TestBootstrapLocalToolsMismatchingOS(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: Currently does not work because of jujud problems")
}
// Client host is a Windows system, wanting to bootstrap a trusty
// controller with local tools. This can't work.
s.PatchValue(&jujuos.HostOS, func() jujuos.OSType { return jujuos.Windows })
s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
s.PatchValue(bootstrap.FindTools, func(environs.Environ, int, int, string, tools.Filter) (tools.List, error) {
return nil, errors.NotFoundf("tools")
})
env := newEnviron("foo", useDefaultKeys, nil)
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
ControllerConfig: coretesting.FakeControllerConfig(),
BuildAgentTarball: func(bool, *version.Number, string) (*sync.BuiltAgent, error) {
return &sync.BuiltAgent{Dir: c.MkDir()}, nil
},
BootstrapSeries: "trusty",
})
c.Assert(err, gc.ErrorMatches, `cannot use agent built for "trusty" using a machine running "Windows"`)
}
func (s *ToolsMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.AddCleanup(dummy.Reset)
cfg, err := config.New(config.UseDefaults, map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"uuid": coretesting.ModelTag.Id(),
"controller-uuid": coretesting.ControllerTag.Id(),
"conroller": true,
})
c.Assert(err, jc.ErrorIsNil)
env, err := bootstrap.Prepare(
modelcmd.BootstrapContextNoVerify(coretesting.Context(c)),
jujuclienttesting.NewMemStore(),
bootstrap.PrepareParams{
ControllerConfig: coretesting.FakeControllerConfig(),
ControllerName: cfg.Name(),
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
},
)
c.Assert(err, jc.ErrorIsNil)
s.env = env
loggo.GetLogger("").SetLogLevel(loggo.INFO)
// Switch the default tools location.
s.publicStorageDir = c.MkDir()
s.PatchValue(&tools.DefaultBaseURL, s.publicStorageDir)
}
func (s *configureSuite) getCloudConfig(c *gc.C, controller bool, vers version.Binary) cloudinit.CloudConfig {
var icfg *instancecfg.InstanceConfig
var err error
modelConfig := testConfig(c, controller, vers)
if controller {
icfg, err = instancecfg.NewBootstrapInstanceConfig(
coretesting.FakeControllerConfig(),
constraints.Value{}, constraints.Value{},
vers.Series, "",
)
c.Assert(err, jc.ErrorIsNil)
icfg.APIInfo = &api.Info{
Password: "******",
CACert: coretesting.CACert,
ModelTag: coretesting.ModelTag,
}
icfg.Controller.MongoInfo = &mongo.MongoInfo{
Password: "******", Info: mongo.Info{CACert: coretesting.CACert},
}
icfg.Bootstrap.ControllerModelConfig = modelConfig
icfg.Bootstrap.BootstrapMachineInstanceId = "instance-id"
icfg.Bootstrap.HostedModelConfig = map[string]interface{}{
"name": "hosted-model",
}
icfg.Bootstrap.StateServingInfo = params.StateServingInfo{
Cert: coretesting.ServerCert,
PrivateKey: coretesting.ServerKey,
CAPrivateKey: coretesting.CAKey,
StatePort: 123,
APIPort: 456,
}
icfg.Jobs = []multiwatcher.MachineJob{multiwatcher.JobManageModel, multiwatcher.JobHostUnits}
icfg.Bootstrap.StateServingInfo = params.StateServingInfo{
Cert: coretesting.ServerCert,
PrivateKey: coretesting.ServerKey,
CAPrivateKey: coretesting.CAKey,
StatePort: 123,
APIPort: 456,
}
} else {
icfg, err = instancecfg.NewInstanceConfig(coretesting.ControllerTag, "0", "ya", imagemetadata.ReleasedStream, vers.Series, nil)
c.Assert(err, jc.ErrorIsNil)
icfg.Jobs = []multiwatcher.MachineJob{multiwatcher.JobHostUnits}
}
err = icfg.SetTools(tools.List{
&tools.Tools{
Version: vers,
URL: "http://testing.invalid/tools.tar.gz",
},
})
err = instancecfg.FinishInstanceConfig(icfg, modelConfig)
c.Assert(err, jc.ErrorIsNil)
cloudcfg, err := cloudinit.New(icfg.Series)
c.Assert(err, jc.ErrorIsNil)
udata, err := cloudconfig.NewUserdataConfig(icfg, cloudcfg)
c.Assert(err, jc.ErrorIsNil)
err = udata.Configure()
c.Assert(err, jc.ErrorIsNil)
return cloudcfg
}
func (s *bootstrapSuite) TestBootstrapMetadataImagesMissing(c *gc.C) {
environs.UnregisterImageDataSourceFunc("bootstrap metadata")
noImagesDir := c.MkDir()
stor, err := filestorage.NewFileStorageWriter(noImagesDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, "released", "released")
env := newEnviron("foo", useDefaultKeys, nil)
s.setDummyStorage(c, env)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
AdminSecret: "admin-secret",
CAPrivateKey: coretesting.CAKey,
MetadataDir: noImagesDir,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.bootstrapCount, gc.Equals, 1)
datasources, err := environs.ImageMetadataSources(env)
c.Assert(err, jc.ErrorIsNil)
c.Assert(datasources, gc.HasLen, 2)
c.Assert(datasources[0].Description(), gc.Equals, "default cloud images")
c.Assert(datasources[1].Description(), gc.Equals, "default ubuntu cloud images")
}
func (s *InitializeSuite) TestInitializeWithInvalidCredentialType(c *gc.C) {
owner := names.NewLocalUserTag("initialize-admin")
modelCfg := testing.ModelConfig(c)
controllerCfg := testing.FakeControllerConfig()
credentialTag := names.NewCloudCredentialTag("dummy/" + owner.Canonical() + "/borken")
_, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: owner,
Config: modelCfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{
cloud.AccessKeyAuthType, cloud.OAuth1AuthType,
},
},
CloudCredentials: map[names.CloudCredentialTag]cloud.Credential{
credentialTag: cloud.NewCredential(cloud.UserPassAuthType, nil),
},
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, gc.ErrorMatches,
`validating initialization args: validating cloud credentials: credential "dummy/initialize-admin@local/borken" with auth-type "userpass" is not supported \(expected one of \["access-key" "oauth1"\]\)`,
)
}
func (suite *maas2Suite) makeEnviron(c *gc.C, controller gomaasapi.Controller) *maasEnviron {
if controller != nil {
suite.injectController(controller)
}
testAttrs := coretesting.Attrs{}
for k, v := range maasEnvAttrs {
testAttrs[k] = v
}
testAttrs["agent-version"] = version.Current.String()
cred := cloud.NewCredential(cloud.OAuth1AuthType, map[string]string{
"maas-oauth": "a:b:c",
})
cloud := environs.CloudSpec{
Type: "maas",
Name: "maas",
Endpoint: "http://any-old-junk.invalid/",
Credential: &cred,
}
attrs := coretesting.FakeConfig().Merge(testAttrs)
suite.controllerUUID = coretesting.FakeControllerConfig().ControllerUUID()
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
env, err := NewEnviron(cloud, cfg)
c.Assert(err, jc.ErrorIsNil)
c.Assert(env, gc.NotNil)
return env
}
func (s *environSuite) TestBootstrap(c *gc.C) {
defer envtesting.DisableFinishBootstrap()()
ctx := envtesting.BootstrapContext(c)
env := prepareForBootstrap(c, ctx, s.provider, &s.sender)
s.sender = s.initResourceGroupSenders()
s.sender = append(s.sender, s.startInstanceSenders(true)...)
s.requests = nil
result, err := env.Bootstrap(
ctx, environs.BootstrapParams{
ControllerConfig: testing.FakeControllerConfig(),
AvailableTools: makeToolsList("quantal"),
BootstrapSeries: "quantal",
},
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result.Arch, gc.Equals, "amd64")
c.Assert(result.Series, gc.Equals, "quantal")
c.Assert(len(s.requests), gc.Equals, numExpectedStartInstanceRequests+1)
s.vmTags[tags.JujuIsController] = to.StringPtr("true")
s.assertStartInstanceRequests(c, s.requests[1:], assertStartInstanceRequestsParams{
availabilitySetName: "juju-controller",
imageReference: &quantalImageReference,
diskSizeGB: 32,
osProfile: &linuxOsProfile,
})
}
func (s *OpenSuite) TestUpdateEnvInfo(c *gc.C) {
store := jujuclienttesting.NewMemStore()
ctx := envtesting.BootstrapContext(c)
uuid := utils.MustNewUUID().String()
cfg, err := config.New(config.UseDefaults, map[string]interface{}{
"type": "dummy",
"name": "admin-model",
"uuid": uuid,
})
c.Assert(err, jc.ErrorIsNil)
controllerCfg := testing.FakeControllerConfig()
_, err = bootstrap.Prepare(ctx, store, bootstrap.PrepareParams{
ControllerConfig: controllerCfg,
ControllerName: "controller-name",
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
})
c.Assert(err, jc.ErrorIsNil)
foundController, err := store.ControllerByName("controller-name")
c.Assert(err, jc.ErrorIsNil)
c.Assert(foundController.ControllerUUID, gc.Not(gc.Equals), "")
c.Assert(foundController.CACert, gc.Not(gc.Equals), "")
foundModel, err := store.ModelByName("controller-name", "admin/admin-model")
c.Assert(err, jc.ErrorIsNil)
c.Assert(foundModel, jc.DeepEquals, &jujuclient.ModelDetails{
ModelUUID: cfg.UUID(),
})
}
func (s *OpenSuite) TestNewDummyEnviron(c *gc.C) {
s.PatchValue(&jujuversion.Current, testing.FakeVersionNumber)
// matches *Settings.Map()
cfg, err := config.New(config.NoDefaults, dummySampleConfig())
c.Assert(err, jc.ErrorIsNil)
ctx := envtesting.BootstrapContext(c)
cache := jujuclienttesting.NewMemStore()
controllerCfg := testing.FakeControllerConfig()
env, err := bootstrap.Prepare(ctx, cache, bootstrap.PrepareParams{
ControllerConfig: controllerCfg,
ControllerName: cfg.Name(),
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
})
c.Assert(err, jc.ErrorIsNil)
storageDir := c.MkDir()
s.PatchValue(&envtools.DefaultBaseURL, storageDir)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, cfg.AgentStream(), cfg.AgentStream())
err = bootstrap.Bootstrap(ctx, env, bootstrap.BootstrapParams{
ControllerConfig: controllerCfg,
AdminSecret: "admin-secret",
CAPrivateKey: testing.CAKey,
})
c.Assert(err, jc.ErrorIsNil)
// New controller should have been added to collection.
foundController, err := cache.ControllerByName(cfg.Name())
c.Assert(err, jc.ErrorIsNil)
c.Assert(foundController.ControllerUUID, gc.DeepEquals, controllerCfg.ControllerUUID())
}
func (*OpenSuite) TestDestroy(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(
testing.Attrs{
"name": "erewhemos",
},
))
c.Assert(err, jc.ErrorIsNil)
store := jujuclienttesting.NewMemStore()
// Prepare the environment and sanity-check that
// the config storage info has been made.
controllerCfg := testing.FakeControllerConfig()
ctx := envtesting.BootstrapContext(c)
e, err := bootstrap.Prepare(ctx, store, bootstrap.PrepareParams{
ControllerConfig: controllerCfg,
ControllerName: "controller-name",
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
})
c.Assert(err, jc.ErrorIsNil)
_, err = store.ControllerByName("controller-name")
c.Assert(err, jc.ErrorIsNil)
err = environs.Destroy("controller-name", e, store)
c.Assert(err, jc.ErrorIsNil)
// Check that the environment has actually been destroyed
// and that the controller details been removed too.
_, err = e.ControllerInstances(controllerCfg.ControllerUUID())
c.Assert(err, gc.ErrorMatches, "model is not prepared")
_, err = store.ControllerByName("controller-name")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *BaseSuiteUnpatched) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
s.ControllerUUID = testing.FakeControllerConfig().ControllerUUID()
s.initEnv(c)
s.initInst(c)
s.initNet(c)
}
func (s *environSuite) TestBootstrap(c *gc.C) {
s.PatchValue(rackspace.Bootstrap, func(ctx environs.BootstrapContext, env environs.Environ, args environs.BootstrapParams) (*environs.BootstrapResult, error) {
return s.innerEnviron.Bootstrap(ctx, args)
})
s.environ.Bootstrap(nil, environs.BootstrapParams{
ControllerConfig: testing.FakeControllerConfig(),
})
c.Check(s.innerEnviron.Pop().name, gc.Equals, "Bootstrap")
}
func (t *Tests) TestBootstrap(c *gc.C) {
credential := t.Credential
if credential.AuthType() == "" {
credential = cloud.NewEmptyCredential()
}
var regions []cloud.Region
if t.CloudRegion != "" {
regions = []cloud.Region{{
Name: t.CloudRegion,
Endpoint: t.CloudEndpoint,
}}
}
args := bootstrap.BootstrapParams{
ControllerConfig: coretesting.FakeControllerConfig(),
CloudName: t.TestConfig["type"].(string),
Cloud: cloud.Cloud{
Type: t.TestConfig["type"].(string),
AuthTypes: []cloud.AuthType{credential.AuthType()},
Regions: regions,
Endpoint: t.CloudEndpoint,
},
CloudRegion: t.CloudRegion,
CloudCredential: &credential,
CloudCredentialName: "credential",
AdminSecret: AdminSecret,
CAPrivateKey: coretesting.CAKey,
}
e := t.Prepare(c)
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), e, args)
c.Assert(err, jc.ErrorIsNil)
controllerInstances, err := e.ControllerInstances(t.ControllerUUID)
c.Assert(err, jc.ErrorIsNil)
c.Assert(controllerInstances, gc.Not(gc.HasLen), 0)
e2 := t.Open(c, e.Config())
controllerInstances2, err := e2.ControllerInstances(t.ControllerUUID)
c.Assert(err, jc.ErrorIsNil)
c.Assert(controllerInstances2, gc.Not(gc.HasLen), 0)
c.Assert(controllerInstances2, jc.SameContents, controllerInstances)
err = environs.Destroy(e2.Config().Name(), e2, t.ControllerStore)
c.Assert(err, jc.ErrorIsNil)
// Prepare again because Destroy invalidates old environments.
e3 := t.Prepare(c)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), e3, args)
c.Assert(err, jc.ErrorIsNil)
err = environs.Destroy(e3.Config().Name(), e3, t.ControllerStore)
c.Assert(err, jc.ErrorIsNil)
}
func (s *environSuite) TestBootstrap(c *gc.C) {
s.PatchValue(&vsphere.Bootstrap, func(ctx environs.BootstrapContext, env environs.Environ, args environs.BootstrapParams,
) (*environs.BootstrapResult, error) {
return nil, errors.New("Bootstrap called")
})
os.Setenv(osenv.JujuFeatureFlagEnvKey, feature.VSphereProvider)
_, err := s.Env.Bootstrap(nil, environs.BootstrapParams{ControllerConfig: testing.FakeControllerConfig()})
c.Assert(err, gc.ErrorMatches, "Bootstrap called")
}
func (s *InitializeSuite) TestInitializeWithCloudRegionHits(c *gc.C) {
cfg := testing.ModelConfig(c)
uuid := cfg.UUID()
controllerInheritedConfigIn := map[string]interface{}{
"no-proxy": "local",
}
// Phony region-config
regionInheritedConfigIn := cloud.RegionConfig{
"a-region": cloud.Attrs{
"no-proxy": "a-value",
},
"b-region": cloud.Attrs{
"no-proxy": "b-value",
},
}
owner := names.NewLocalUserTag("initialize-admin")
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: owner,
Config: cfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
RegionConfig: regionInheritedConfigIn, // Init with phony region-config
},
ControllerInheritedConfig: controllerInheritedConfigIn,
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.NotNil)
modelTag := st.ModelTag()
c.Assert(modelTag.Id(), gc.Equals, uuid)
err = st.Close()
c.Assert(err, jc.ErrorIsNil)
s.openState(c, modelTag)
var attrs map[string]interface{}
for r := range regionInheritedConfigIn {
rspec := &environs.RegionSpec{Cloud: "dummy", Region: r}
got, err := s.State.ComposeNewModelConfig(attrs, rspec)
c.Check(err, jc.ErrorIsNil)
c.Assert(got["no-proxy"], gc.Equals, regionInheritedConfigIn[r]["no-proxy"])
}
}
func (s *InitializeSuite) TestInitializeWithCloudRegionConfig(c *gc.C) {
cfg := testing.ModelConfig(c)
uuid := cfg.UUID()
// Phony region-config
regionInheritedConfigIn := cloud.RegionConfig{
"a-region": cloud.Attrs{
"a-key": "a-value",
},
"b-region": cloud.Attrs{
"b-key": "b-value",
},
}
owner := names.NewLocalUserTag("initialize-admin")
controllerCfg := testing.FakeControllerConfig()
st, err := state.Initialize(state.InitializeParams{
Clock: clock.WallClock,
ControllerConfig: controllerCfg,
ControllerModelArgs: state.ModelArgs{
CloudName: "dummy",
Owner: owner,
Config: cfg,
StorageProviderRegistry: storage.StaticProviderRegistry{},
},
CloudName: "dummy",
Cloud: cloud.Cloud{
Type: "dummy",
AuthTypes: []cloud.AuthType{cloud.EmptyAuthType},
RegionConfig: regionInheritedConfigIn, // Init with phony region-config
},
MongoInfo: statetesting.NewMongoInfo(),
MongoDialOpts: mongotest.DialOpts(),
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.NotNil)
modelTag := st.ModelTag()
c.Assert(modelTag.Id(), gc.Equals, uuid)
err = st.Close()
c.Assert(err, jc.ErrorIsNil)
s.openState(c, modelTag)
for k := range regionInheritedConfigIn {
// Query for config for each region
regionInheritedConfig, err := state.ReadSettings(
s.State, state.GlobalSettingsC,
"dummy#"+k)
c.Assert(err, jc.ErrorIsNil)
c.Assert(
cloud.Attrs(regionInheritedConfig.Map()),
jc.DeepEquals,
regionInheritedConfigIn[k])
}
}
func (s *withoutControllerSuite) TestStorageProviderFallbackToType(c *gc.C) {
template := state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
Placement: "valid",
Volumes: []state.MachineVolumeParams{
{Volume: state.VolumeParams{Size: 1000, Pool: "environscoped"}},
{Volume: state.VolumeParams{Size: 1000, Pool: "static"}},
},
}
placementMachine, err := s.State.AddOneMachine(template)
c.Assert(err, jc.ErrorIsNil)
args := params.Entities{Entities: []params.Entity{
{Tag: placementMachine.Tag().String()},
}}
result, err := s.provisioner.ProvisioningInfo(args)
c.Assert(err, jc.ErrorIsNil)
controllerCfg := coretesting.FakeControllerConfig()
// Dummy provider uses a random port, which is added to cfg used to create environment.
apiPort := dummy.ApiPort(s.Environ.Provider())
controllerCfg["api-port"] = apiPort
c.Assert(result, jc.DeepEquals, params.ProvisioningInfoResults{
Results: []params.ProvisioningInfoResult{
{Result: ¶ms.ProvisioningInfo{
ControllerConfig: controllerCfg,
Series: "quantal",
Constraints: template.Constraints,
Placement: template.Placement,
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
Tags: map[string]string{
tags.JujuController: coretesting.ControllerTag.Id(),
tags.JujuModel: coretesting.ModelTag.Id(),
},
Volumes: []params.VolumeParams{{
VolumeTag: "volume-1",
Size: 1000,
Provider: "static",
Attributes: nil,
Tags: map[string]string{
tags.JujuController: coretesting.ControllerTag.Id(),
tags.JujuModel: coretesting.ModelTag.Id(),
},
Attachment: ¶ms.VolumeAttachmentParams{
MachineTag: placementMachine.Tag().String(),
VolumeTag: "volume-1",
Provider: "static",
},
}},
}},
},
})
}