func (s *toolsSuite) testFindToolsExact(c *gc.C, t common.ToolsStorageGetter, inStorage bool, develVersion bool) {
var called bool
s.PatchValue(common.EnvtoolsFindTools, func(e environs.Environ, major, minor int, stream string, filter coretools.Filter) (list coretools.List, err error) {
called = true
c.Assert(filter.Number, gc.Equals, version.Current.Number)
c.Assert(filter.Series, gc.Equals, series.HostSeries())
c.Assert(filter.Arch, gc.Equals, arch.HostArch())
if develVersion {
c.Assert(stream, gc.Equals, "devel")
} else {
c.Assert(stream, gc.Equals, "released")
}
return nil, errors.NotFoundf("tools")
})
toolsFinder := common.NewToolsFinder(s.State, t, sprintfURLGetter("tools:%s"))
result, err := toolsFinder.FindTools(params.FindToolsParams{
Number: version.Current.Number,
MajorVersion: -1,
MinorVersion: -1,
Series: series.HostSeries(),
Arch: arch.HostArch(),
})
c.Assert(err, jc.ErrorIsNil)
if inStorage {
c.Assert(result.Error, gc.IsNil)
c.Assert(called, jc.IsFalse)
} else {
c.Assert(result.Error, gc.ErrorMatches, "tools not found")
c.Assert(called, jc.IsTrue)
}
}
// Bootstrap is specified in the Environ interface.
func (env *localEnviron) Bootstrap(ctx environs.BootstrapContext, args environs.BootstrapParams) (string, string, environs.BootstrapFinalizer, error) {
if err := ensureNotRoot(); err != nil {
return "", "", nil, err
}
// Make sure there are tools available for the
// host's architecture and series.
if _, err := args.AvailableTools.Match(tools.Filter{
Arch: arch.HostArch(),
Series: series.HostSeries(),
}); err != nil {
return "", "", nil, err
}
cfg, err := env.Config().Apply(map[string]interface{}{
// Record the bootstrap IP, so the containers know where to go for storage.
"bootstrap-ip": env.bridgeAddress,
})
if err == nil {
err = env.SetConfig(cfg)
}
if err != nil {
logger.Errorf("failed to apply bootstrap-ip to config: %v", err)
return "", "", nil, err
}
return arch.HostArch(), series.HostSeries(), env.finishBootstrap, nil
}
func (s *format_1_18Suite) TestMissingAttributes(c *gc.C) {
logDir, err := paths.LogDir(series.HostSeries())
c.Assert(err, jc.ErrorIsNil)
realDataDir, err := paths.DataDir(series.HostSeries())
c.Assert(err, jc.ErrorIsNil)
realDataDir = filepath.FromSlash(realDataDir)
logPath := filepath.Join(logDir, "juju")
logPath = filepath.FromSlash(logPath)
dataDir := c.MkDir()
configPath := filepath.Join(dataDir, agentConfigFilename)
err = utils.AtomicWriteFile(configPath, []byte(configData1_18WithoutUpgradedToVersion), 0600)
c.Assert(err, jc.ErrorIsNil)
readConfig, err := ReadConfig(configPath)
c.Assert(err, jc.ErrorIsNil)
c.Assert(readConfig.UpgradedToVersion(), gc.Equals, version.MustParse("1.16.0"))
configLogDir := filepath.FromSlash(readConfig.LogDir())
configDataDir := filepath.FromSlash(readConfig.DataDir())
c.Assert(configLogDir, gc.Equals, logPath)
c.Assert(configDataDir, gc.Equals, realDataDir)
c.Assert(readConfig.PreferIPv6(), jc.IsFalse)
// The api info doesn't have the environment tag set.
c.Assert(readConfig.APIInfo().EnvironTag.Id(), gc.Equals, "")
}
func (s *uploadSuite) TestUploadFakeSeries(c *gc.C) {
seriesToUpload := "precise"
if seriesToUpload == series.HostSeries() {
seriesToUpload = "raring"
}
t, err := sync.Upload(s.targetStorage, "released", nil, "quantal", seriesToUpload)
c.Assert(err, jc.ErrorIsNil)
s.assertUploadedTools(c, t, []string{seriesToUpload, "quantal", series.HostSeries()}, "released")
}
func (s *uploadSuite) TestSyncToolsFakeSeries(c *gc.C) {
seriesToUpload := "precise"
if seriesToUpload == series.HostSeries() {
seriesToUpload = "raring"
}
builtTools, err := sync.BuildToolsTarball(nil, "testing")
c.Assert(err, jc.ErrorIsNil)
t, err := sync.SyncBuiltTools(s.targetStorage, "testing", builtTools, "quantal", seriesToUpload)
c.Assert(err, jc.ErrorIsNil)
s.assertUploadedTools(c, t, []string{seriesToUpload, "quantal", series.HostSeries()}, "testing")
}
func (*CurrentSuite) TestCurrentSeries(c *gc.C) {
s := series.HostSeries()
if s == "unknown" {
s = "n/a"
}
out, err := exec.Command("lsb_release", "-c").CombinedOutput()
if err != nil {
// If the command fails (for instance if we're running on some other
// platform) then CurrentSeries should be unknown.
switch runtime.GOOS {
case "darwin":
c.Check(s, gc.Matches, `mavericks|mountainlion|lion|snowleopard`)
case "windows":
c.Check(s, gc.Matches, `win2012hvr2|win2012hv|win2012|win2012r2|win8|win81|win7`)
default:
current_os, err := series.GetOSFromSeries(s)
c.Assert(err, gc.IsNil)
if s != "n/a" {
// There is no lsb_release command on CentOS.
if current_os == os.CentOS {
c.Check(s, gc.Matches, `centos7`)
}
}
}
} else {
c.Assert(string(out), gc.Equals, "Codename:\t"+s+"\n")
}
}
func (s *prereqsSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.tmpdir = c.MkDir()
s.testMongodPath = filepath.Join(s.tmpdir, "mongod")
s.PatchEnvironment("PATH", s.tmpdir)
s.PatchValue(&mongo.JujuMongodPath, "/somewhere/that/wont/exist")
os.Setenv("JUJUTEST_LSB_RELEASE_ID", "Ubuntu")
err := ioutil.WriteFile(filepath.Join(s.tmpdir, "lsb_release"), []byte(lsbrelease), 0777)
c.Assert(err, jc.ErrorIsNil)
// symlink $temp/dpkg-query to /bin/true, to
// simulate package installation query responses.
pm, err := testing.GetPackageManager()
c.Assert(err, jc.ErrorIsNil)
err = symlink.New("/bin/true", filepath.Join(s.tmpdir, pm.PackageQuery))
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(&isPackageInstalled, func(pack string) bool {
pacman, err := manager.NewPackageManager(series.HostSeries())
c.Assert(err, jc.ErrorIsNil)
return pacman.IsInstalled(pack)
})
}
// ListServices lists all installed services on the running system
func ListServices() ([]string, error) {
initName, err := VersionInitSystem(series.HostSeries())
if err != nil {
return nil, errors.Trace(err)
}
switch initName {
case InitSystemWindows:
services, err := windows.ListServices()
if err != nil {
return nil, errors.Annotatef(err, "failed to list %s services", initName)
}
return services, nil
case InitSystemUpstart:
services, err := upstart.ListServices()
if err != nil {
return nil, errors.Annotatef(err, "failed to list %s services", initName)
}
return services, nil
case InitSystemSystemd:
services, err := systemd.ListServices()
if err != nil {
return nil, errors.Annotatef(err, "failed to list %s services", initName)
}
return services, nil
default:
return nil, errors.NotFoundf("init system %q", initName)
}
}
func (s *uploadSuite) TestUpload(c *gc.C) {
t, err := sync.Upload(s.targetStorage, "released", nil)
c.Assert(err, jc.ErrorIsNil)
c.Assert(t.Version, gc.Equals, version.Current)
c.Assert(t.URL, gc.Not(gc.Equals), "")
s.assertUploadedTools(c, t, []string{series.HostSeries()}, "released")
}
func getContainerInstance() (cont []ContainerInstance, err error) {
current_os, err := series.GetOSFromSeries(series.HostSeries())
if err != nil {
return nil, err
}
switch current_os {
case jujuos.CentOS:
cont = []ContainerInstance{
{instance.LXC, [][]string{
{"lxc"},
{"cloud-image-utils"},
}},
{instance.KVM, [][]string{
{"uvtool-libvirt"},
{"uvtool"},
}},
}
default:
cont = []ContainerInstance{
{instance.LXC, [][]string{
{"--target-release", "precise-updates/cloud-tools", "lxc"},
{"--target-release", "precise-updates/cloud-tools", "cloud-image-utils"},
}},
{instance.KVM, [][]string{
{"uvtool-libvirt"},
{"uvtool"},
}},
}
}
return cont, nil
}
func (e *bootstrapEnviron) Bootstrap(ctx environs.BootstrapContext, args environs.BootstrapParams) (string, string, environs.BootstrapFinalizer, error) {
e.bootstrapCount++
e.args = args
finalizer := func(_ environs.BootstrapContext, icfg *instancecfg.InstanceConfig) error {
e.finalizerCount++
e.instanceConfig = icfg
return nil
}
return arch.HostArch(), series.HostSeries(), finalizer, nil
}
// DiscoverService returns an interface to a service appropriate
// for the current system
func DiscoverService(name string, conf common.Conf) (Service, error) {
initName, err := discoverInitSystem()
if err != nil {
return nil, errors.Trace(err)
}
service, err := newService(name, conf, initName, series.HostSeries())
if err != nil {
return nil, errors.Trace(err)
}
return service, nil
}
func (s *provisionerSuite) testFindTools(c *gc.C, matchArch bool, apiError, logicError error) {
var toolsList = coretools.List{&coretools.Tools{Version: version.Current}}
var called bool
var a string
if matchArch {
// if matchArch is true, this will be overwriten with the host's arch, otherwise
// leave a blank.
a = arch.HostArch()
}
provisioner.PatchFacadeCall(s, s.provisioner, func(request string, args, response interface{}) error {
called = true
c.Assert(request, gc.Equals, "FindTools")
expected := params.FindToolsParams{
Number: version.Current.Number,
Series: series.HostSeries(),
Arch: a,
MinorVersion: -1,
MajorVersion: -1,
}
c.Assert(args, gc.Equals, expected)
result := response.(*params.FindToolsResult)
result.List = toolsList
if logicError != nil {
result.Error = common.ServerError(logicError)
}
return apiError
})
apiList, err := s.provisioner.FindTools(version.Current.Number, series.HostSeries(), a)
c.Assert(called, jc.IsTrue)
if apiError != nil {
c.Assert(err, gc.Equals, apiError)
} else if logicError != nil {
c.Assert(err.Error(), gc.Equals, logicError.Error())
} else {
c.Assert(err, jc.ErrorIsNil)
c.Assert(apiList, jc.SameContents, toolsList)
}
}
func (s *ProxyUpdaterSuite) TestInitialState(c *gc.C) {
proxySettings, aptProxySettings := s.updateConfig(c)
updater := proxyupdater.New(s.environmentAPI, true)
defer worker.Stop(updater)
s.waitProxySettings(c, proxySettings)
s.waitForFile(c, s.proxyFile, proxySettings.AsScriptEnvironment()+"\n")
paccmder, err := commands.NewPackageCommander(series.HostSeries())
c.Assert(err, jc.ErrorIsNil)
s.waitForFile(c, pacconfig.AptProxyConfigFile, paccmder.ProxyConfigContents(aptProxySettings)+"\n")
}
func (w *proxyWorker) writeEnvironment() error {
// TODO(dfc) this should be replaced with a switch on os.HostOS()
osystem, err := series.GetOSFromSeries(series.HostSeries())
if err != nil {
return err
}
switch osystem {
case os.Windows:
return w.writeEnvironmentToRegistry()
default:
return w.writeEnvironmentFile()
}
}
func minimalConfig(c *gc.C) *config.Config {
attrs := map[string]interface{}{
"name": "whatever",
"type": "anything, really",
"uuid": coretesting.EnvironmentTag.Id(),
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
"authorized-keys": coretesting.FakeAuthKeys,
"default-series": series.HostSeries(),
}
cfg, err := config.New(config.UseDefaults, attrs)
c.Assert(err, jc.ErrorIsNil)
return cfg
}
func uploadFakeTools(stor storage.Storage, toolsDir, stream string) error {
toolsSeries := set.NewStrings(toolsLtsSeries...)
toolsSeries.Add(series.HostSeries())
var versions []version.Binary
for _, series := range toolsSeries.Values() {
vers := version.Current
vers.Series = series
versions = append(versions, vers)
}
if _, err := UploadFakeToolsVersions(stor, toolsDir, stream, versions...); err != nil {
return err
}
return nil
}
func (s *discoverySuite) TestDiscoverServiceLocalHost(c *gc.C) {
var localInitSystem string
var err error
switch runtime.GOOS {
case "windows":
localInitSystem = service.InitSystemWindows
case "linux":
localInitSystem, err = service.VersionInitSystem(series.HostSeries())
}
c.Assert(err, gc.IsNil)
test := discoveryTest{
os: version.Current.OS,
series: series.HostSeries(),
expected: localInitSystem,
}
test.disableVersionDiscovery(s)
svc, err := service.DiscoverService(s.name, s.conf)
c.Assert(err, jc.ErrorIsNil)
test.checkService(c, svc, err, s.name, s.conf)
}
func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) {
envtesting.RemoveFakeToolsMetadata(c, s.toolsStorage)
_, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.b64yamlEnvcfg, "--instance-id", string(s.instanceId))
c.Assert(err, jc.ErrorIsNil)
err = cmd.Run(nil)
c.Assert(err, jc.ErrorIsNil)
// We don't write metadata at bootstrap anymore.
simplestreamsMetadata, err := envtools.ReadMetadata(s.toolsStorage, "released")
c.Assert(err, jc.ErrorIsNil)
c.Assert(simplestreamsMetadata, gc.HasLen, 0)
// The tools should have been added to tools storage, and
// exploded into each of the supported series of
// the same operating system if the tools were uploaded.
st, err := state.Open(testing.EnvironmentTag, &mongo.MongoInfo{
Info: mongo.Info{
Addrs: []string{gitjujutesting.MgoServer.Addr()},
CACert: testing.CACert,
},
Password: testPasswordHash(),
}, mongo.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, jc.ErrorIsNil)
defer st.Close()
expectedSeries := make(set.Strings)
if exploded {
for _, ser := range series.SupportedSeries() {
os, err := series.GetOSFromSeries(ser)
c.Assert(err, jc.ErrorIsNil)
hostos, err := series.GetOSFromSeries(version.Current.Series)
c.Assert(err, jc.ErrorIsNil)
if os == hostos {
expectedSeries.Add(ser)
}
}
} else {
expectedSeries.Add(series.HostSeries())
}
storage, err := st.ToolsStorage()
c.Assert(err, jc.ErrorIsNil)
defer storage.Close()
metadata, err := storage.AllMetadata()
c.Assert(err, jc.ErrorIsNil)
c.Assert(metadata, gc.HasLen, expectedSeries.Size())
for _, m := range metadata {
c.Assert(expectedSeries.Contains(m.Version.Series), jc.IsTrue)
}
}
// RemoveFakeTools deletes the fake tools from the supplied storage.
func RemoveFakeTools(c *gc.C, stor storage.Storage, toolsDir string) {
c.Logf("removing fake tools")
toolsVersion := version.Current
name := envtools.StorageName(toolsVersion, toolsDir)
err := stor.Remove(name)
c.Check(err, jc.ErrorIsNil)
defaultSeries := coretesting.FakeDefaultSeries
if series.HostSeries() != defaultSeries {
toolsVersion.Series = defaultSeries
name := envtools.StorageName(toolsVersion, toolsDir)
err := stor.Remove(name)
c.Check(err, jc.ErrorIsNil)
}
RemoveFakeToolsMetadata(c, stor)
}
func discoverInitSystem() (string, error) {
initName, err := discoverLocalInitSystem()
if errors.IsNotFound(err) {
// Fall back to checking the juju version.
versionInitName, err2 := VersionInitSystem(series.HostSeries())
if err2 != nil {
// The key error is the one from discoverLocalInitSystem so
// that is what we return.
return "", errors.Wrap(err2, err)
}
initName = versionInitName
} else if err != nil {
return "", errors.Trace(err)
}
return initName, nil
}
// CheckAgentCommand is a utility function for verifying that common agent
// options are handled by a Command; it returns an instance of that
// command pre-parsed, with any mandatory flags added.
func CheckAgentCommand(c *gc.C, create acCreator, args []string) cmd.Command {
com, conf := create()
err := coretesting.InitCommand(com, args)
dataDir, err := paths.DataDir(series.HostSeries())
c.Assert(err, jc.ErrorIsNil)
c.Assert(conf.DataDir(), gc.Equals, dataDir)
badArgs := append(args, "--data-dir", "")
com, _ = create()
err = coretesting.InitCommand(com, badArgs)
c.Assert(err, gc.ErrorMatches, "--data-dir option must be set")
args = append(args, "--data-dir", "jd")
com, conf = create()
c.Assert(coretesting.InitCommand(com, args), gc.IsNil)
c.Assert(conf.DataDir(), gc.Equals, "jd")
return com
}
// initBootstrapMachine initializes the initial bootstrap machine in state.
func initBootstrapMachine(c ConfigSetter, st *state.State, cfg BootstrapMachineConfig) (*state.Machine, error) {
logger.Infof("initialising bootstrap machine with config: %+v", cfg)
jobs := make([]state.MachineJob, len(cfg.Jobs))
for i, job := range cfg.Jobs {
machineJob, err := machineJobFromParams(job)
if err != nil {
return nil, errors.Errorf("invalid bootstrap machine job %q: %v", job, err)
}
jobs[i] = machineJob
}
m, err := st.AddOneMachine(state.MachineTemplate{
Addresses: cfg.Addresses,
Series: series.HostSeries(),
Nonce: BootstrapNonce,
Constraints: cfg.Constraints,
InstanceId: cfg.InstanceId,
HardwareCharacteristics: cfg.Characteristics,
Jobs: jobs,
})
if err != nil {
return nil, errors.Errorf("cannot create bootstrap machine in state: %v", err)
}
if m.Id() != BootstrapMachineId {
return nil, errors.Errorf("bootstrap machine expected id 0, got %q", m.Id())
}
// Read the machine agent's password and change it to
// a new password (other agents will change their password
// via the API connection).
logger.Debugf("create new random password for machine %v", m.Id())
newPassword, err := utils.RandomPassword()
if err != nil {
return nil, err
}
if err := m.SetPassword(newPassword); err != nil {
return nil, err
}
if err := m.SetMongoPassword(newPassword); err != nil {
return nil, err
}
c.SetPassword(newPassword)
return m, nil
}
func (s *ContainerSetupSuite) testContainerConstraintsArch(c *gc.C, containerType instance.ContainerType, expectArch string) {
var called bool
s.PatchValue(provisioner.GetToolsFinder, func(*apiprovisioner.State) provisioner.ToolsFinder {
return toolsFinderFunc(func(v version.Number, series string, arch string) (tools.List, error) {
called = true
c.Assert(arch, gc.Equals, expectArch)
result := version.Current
result.Number = v
result.Series = series
result.Arch = arch
return tools.List{{Version: result}}, nil
})
})
s.PatchValue(&provisioner.StartProvisioner, func(runner worker.Runner, containerType instance.ContainerType,
pr *apiprovisioner.State, cfg agent.Config, broker environs.InstanceBroker,
toolsFinder provisioner.ToolsFinder) error {
toolsFinder.FindTools(version.Current.Number, series.HostSeries(), arch.AMD64)
return nil
})
// create a machine to host the container.
m, err := s.BackingState.AddOneMachine(state.MachineTemplate{
Series: coretesting.FakeDefaultSeries,
Jobs: []state.MachineJob{state.JobHostUnits},
Constraints: s.defaultConstraints,
})
c.Assert(err, jc.ErrorIsNil)
err = m.SetSupportedContainers([]instance.ContainerType{containerType})
c.Assert(err, jc.ErrorIsNil)
err = m.SetAgentVersion(version.Current)
c.Assert(err, jc.ErrorIsNil)
s.createContainer(c, m, containerType)
<-s.aptCmdChan
c.Assert(called, jc.IsTrue)
}
if cfg.APIInfo.Tag != names.NewMachineTag(cfg.MachineId) {
return errors.New("entity tag must match started machine")
}
if cfg.StateServingInfo != nil {
return errors.New("state serving info unexpectedly present")
}
}
if cfg.MachineNonce == "" {
return errors.New("missing machine nonce")
}
return nil
}
// logDir returns a filesystem path to the location where applications
// may create a folder containing logs
var logDir = paths.MustSucceed(paths.LogDir(series.HostSeries()))
// DefaultBridgeName is the network bridge device name used for LXC and KVM
// containers
const DefaultBridgeName = "juju-br0"
// NewInstanceConfig sets up a basic machine configuration, for a
// non-bootstrap node. You'll still need to supply more information,
// but this takes care of the fixed entries and the ones that are
// always needed.
func NewInstanceConfig(
machineID,
machineNonce,
imageStream,
series string,
secureServerConnections bool,
"github.com/juju/juju/api"
"github.com/juju/juju/apiserver/params"
"github.com/juju/juju/juju/paths"
"github.com/juju/juju/juju/series"
"github.com/juju/juju/mongo"
"github.com/juju/juju/network"
"github.com/juju/juju/state/multiwatcher"
"github.com/juju/juju/version"
)
var logger = loggo.GetLogger("juju.agent")
// These are base values used for the corresponding defaults.
var (
logDir = paths.MustSucceed(paths.LogDir(series.HostSeries()))
dataDir = paths.MustSucceed(paths.DataDir(series.HostSeries()))
confDir = paths.MustSucceed(paths.ConfDir(series.HostSeries()))
metricsSpoolDir = paths.MustSucceed(paths.MetricsSpoolDir(series.HostSeries()))
)
// Agent exposes the agent's configuration to other components. This
// interface should probably be segregated (agent.ConfigGetter and
// agent.ConfigChanger?) but YAGNI *currently* advises against same.
type Agent interface {
// CurrentConfig returns a copy of the agent's configuration. No
// guarantees regarding ongoing correctness are made.
CurrentConfig() Config
// ChangeConfig allows clients to change the agent's configuration
func (s *bootstrapSuite) testInitializeState(c *gc.C, fakeLocalEnv bool) {
dataDir := c.MkDir()
lxcFakeNetConfig := filepath.Join(c.MkDir(), "lxc-net")
netConf := []byte(`
# comments ignored
LXC_BR= ignored
LXC_ADDR = "fooo"
LXC_BRIDGE="foobar" # detected
anything else ignored
LXC_BRIDGE="ignored"`[1:])
err := ioutil.WriteFile(lxcFakeNetConfig, netConf, 0644)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(&network.InterfaceByNameAddrs, func(name string) ([]net.Addr, error) {
c.Assert(name, gc.Equals, "foobar")
return []net.Addr{
&net.IPAddr{IP: net.IPv4(10, 0, 3, 1)},
&net.IPAddr{IP: net.IPv4(10, 0, 3, 4)},
}, nil
})
s.PatchValue(&network.LXCNetDefaultConfig, lxcFakeNetConfig)
s.PatchValue(agent.IsLocalEnv, func(*config.Config) bool {
c.Logf("fakeLocalEnv=%v", fakeLocalEnv)
return fakeLocalEnv
})
pwHash := utils.UserPasswordHash(testing.DefaultMongoPassword, utils.CompatSalt)
configParams := agent.AgentConfigParams{
Paths: agent.Paths{DataDir: dataDir},
Tag: names.NewMachineTag("0"),
UpgradedToVersion: version.Current.Number,
StateAddresses: []string{s.mgoInst.Addr()},
CACert: testing.CACert,
Password: pwHash,
Environment: testing.EnvironmentTag,
}
servingInfo := params.StateServingInfo{
Cert: testing.ServerCert,
PrivateKey: testing.ServerKey,
CAPrivateKey: testing.CAKey,
APIPort: 1234,
StatePort: s.mgoInst.Port(),
SystemIdentity: "def456",
}
cfg, err := agent.NewStateMachineConfig(configParams, servingInfo)
c.Assert(err, jc.ErrorIsNil)
_, available := cfg.StateServingInfo()
c.Assert(available, jc.IsTrue)
expectConstraints := constraints.MustParse("mem=1024M")
expectHW := instance.MustParseHardware("mem=2048M")
initialAddrs := network.NewAddresses(
"zeroonetwothree",
"0.1.2.3",
"10.0.3.1", // lxc bridge address filtered (when fakeLocalEnv=false).
"10.0.3.4", // lxc bridge address filtered (-"-).
"10.0.3.3", // not a lxc bridge address
)
mcfg := agent.BootstrapMachineConfig{
Addresses: initialAddrs,
Constraints: expectConstraints,
Jobs: []multiwatcher.MachineJob{multiwatcher.JobManageEnviron},
InstanceId: "i-bootstrap",
Characteristics: expectHW,
SharedSecret: "abc123",
}
filteredAddrs := network.NewAddresses(
"zeroonetwothree",
"0.1.2.3",
"10.0.3.3",
)
if fakeLocalEnv {
// For local environments - no filtering.
filteredAddrs = append([]network.Address{}, initialAddrs...)
}
envAttrs := dummy.SampleConfig().Delete("admin-secret").Merge(testing.Attrs{
"agent-version": version.Current.Number.String(),
"state-id": "1", // needed so policy can Open config
})
envCfg, err := config.New(config.NoDefaults, envAttrs)
c.Assert(err, jc.ErrorIsNil)
adminUser := names.NewLocalUserTag("agent-admin")
st, m, err := agent.InitializeState(adminUser, cfg, envCfg, mcfg, mongo.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, jc.ErrorIsNil)
defer st.Close()
err = cfg.Write()
c.Assert(err, jc.ErrorIsNil)
// Check that the environment has been set up.
env, err := st.Environment()
c.Assert(err, jc.ErrorIsNil)
uuid, ok := envCfg.UUID()
c.Assert(ok, jc.IsTrue)
c.Assert(env.UUID(), gc.Equals, uuid)
// Check that initial admin user has been set up correctly.
envTag := env.Tag().(names.EnvironTag)
s.assertCanLogInAsAdmin(c, envTag, pwHash)
user, err := st.User(env.Owner())
c.Assert(err, jc.ErrorIsNil)
c.Assert(user.PasswordValid(testing.DefaultMongoPassword), jc.IsTrue)
// Check that environment configuration has been added.
newEnvCfg, err := st.EnvironConfig()
c.Assert(err, jc.ErrorIsNil)
c.Assert(newEnvCfg.AllAttrs(), gc.DeepEquals, envCfg.AllAttrs())
// Check that the bootstrap machine looks correct.
c.Assert(m.Id(), gc.Equals, "0")
c.Assert(m.Jobs(), gc.DeepEquals, []state.MachineJob{state.JobManageEnviron})
c.Assert(m.Series(), gc.Equals, series.HostSeries())
c.Assert(m.CheckProvisioned(agent.BootstrapNonce), jc.IsTrue)
c.Assert(m.Addresses(), jc.DeepEquals, filteredAddrs)
gotConstraints, err := m.Constraints()
c.Assert(err, jc.ErrorIsNil)
c.Assert(gotConstraints, gc.DeepEquals, expectConstraints)
c.Assert(err, jc.ErrorIsNil)
gotHW, err := m.HardwareCharacteristics()
c.Assert(err, jc.ErrorIsNil)
c.Assert(*gotHW, gc.DeepEquals, expectHW)
// Check that the API host ports are initialised correctly.
apiHostPorts, err := st.APIHostPorts()
c.Assert(err, jc.ErrorIsNil)
c.Assert(apiHostPorts, jc.DeepEquals, [][]network.HostPort{
network.AddressesWithPort(filteredAddrs, 1234),
})
// Check that the state serving info is initialised correctly.
stateServingInfo, err := st.StateServingInfo()
c.Assert(err, jc.ErrorIsNil)
c.Assert(stateServingInfo, jc.DeepEquals, state.StateServingInfo{
APIPort: 1234,
StatePort: s.mgoInst.Port(),
Cert: testing.ServerCert,
PrivateKey: testing.ServerKey,
CAPrivateKey: testing.CAKey,
SharedSecret: "abc123",
SystemIdentity: "def456",
})
// Check that the machine agent's config has been written
// and that we can use it to connect to the state.
machine0 := names.NewMachineTag("0")
newCfg, err := agent.ReadConfig(agent.ConfigPath(dataDir, machine0))
c.Assert(err, jc.ErrorIsNil)
c.Assert(newCfg.Tag(), gc.Equals, machine0)
c.Assert(agent.Password(newCfg), gc.Not(gc.Equals), pwHash)
c.Assert(agent.Password(newCfg), gc.Not(gc.Equals), testing.DefaultMongoPassword)
info, ok := cfg.MongoInfo()
c.Assert(ok, jc.IsTrue)
st1, err := state.Open(newCfg.Environment(), info, mongo.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, jc.ErrorIsNil)
defer st1.Close()
}
func (s *ContainerSetupSuite) assertContainerInitialised(c *gc.C, cont ContainerInstance, addressable bool) {
// A noop worker callback.
startProvisionerWorker := func(runner worker.Runner, containerType instance.ContainerType,
pr *apiprovisioner.State, cfg agent.Config, broker environs.InstanceBroker,
toolsFinder provisioner.ToolsFinder) error {
return nil
}
s.PatchValue(&provisioner.StartProvisioner, startProvisionerWorker)
current_os, err := series.GetOSFromSeries(series.HostSeries())
c.Assert(err, jc.ErrorIsNil)
var ser string
var expected_initial []string
switch current_os {
case jujuos.CentOS:
ser = "centos7"
expected_initial = []string{
"yum", "--assumeyes", "--debuglevel=1", "install"}
default:
ser = "precise"
expected_initial = []string{
"apt-get", "--option=Dpkg::Options::=--force-confold",
"--option=Dpkg::options::=--force-unsafe-io", "--assume-yes", "--quiet",
"install"}
}
// create a machine to host the container.
m, err := s.BackingState.AddOneMachine(state.MachineTemplate{
Series: ser, // precise requires special apt parameters, so we use that series here.
Jobs: []state.MachineJob{state.JobHostUnits},
Constraints: s.defaultConstraints,
})
c.Assert(err, jc.ErrorIsNil)
err = m.SetSupportedContainers([]instance.ContainerType{instance.LXC, instance.KVM})
c.Assert(err, jc.ErrorIsNil)
err = m.SetAgentVersion(version.Current)
c.Assert(err, jc.ErrorIsNil)
// Before starting /etc/default/lxc-net should be missing.
c.Assert(s.fakeLXCNet, jc.DoesNotExist)
s.createContainer(c, m, cont.ctype)
// Only feature-flagged addressable containers modify lxc-net.
if addressable {
// After initialisation starts, but before running the
// initializer, lxc-net should be created if cont.ctype is LXC, as the
// dummy provider supports static address allocation by default.
if cont.ctype == instance.LXC {
AssertFileContains(c, s.fakeLXCNet, provisioner.EtcDefaultLXCNet)
defer os.Remove(s.fakeLXCNet)
} else {
c.Assert(s.fakeLXCNet, jc.DoesNotExist)
}
}
for _, pack := range cont.packages {
cmd := <-s.aptCmdChan
expected := append(expected_initial, pack...)
c.Assert(cmd.Args, gc.DeepEquals, expected)
}
}
// getPackageManager is a helper function which returns the
// package manager implementation for the current system.
func getPackageManager() (manager.PackageManager, error) {
return manager.NewPackageManager(series.HostSeries())
}
// number of the release package.
const version = "1.26-alpha1"
// The version that we switched over from old style numbering to new style.
var switchOverVersion = MustParse("1.19.9")
// osReleaseFile is the name of the file that is read in order to determine
// the linux type release version.
var osReleaseFile = "/etc/os-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: series.HostSeries(),
Arch: arch.HostArch(),
OS: series.MustOSFromSeries(series.HostSeries()),
}
var Compiler = runtime.Compiler
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
}
