// Bootstrap is a common implementation of the Bootstrap method defined on
// environs.Environ; we strongly recommend that this implementation be used
// when writing a new provider.
func Bootstrap(ctx environs.BootstrapContext, env environs.Environ, args environs.BootstrapParams) (err error) {
// TODO make safe in the case of racing Bootstraps
// If two Bootstraps are called concurrently, there's
// no way to make sure that only one succeeds.
var inst instance.Instance
defer func() { handleBootstrapError(err, ctx, inst, env) }()
network.InitializeFromConfig(env.Config())
// First thing, ensure we have tools otherwise there's no point.
selectedTools, err := EnsureBootstrapTools(ctx, env, config.PreferredSeries(env.Config()), args.Constraints.Arch)
if err != nil {
return err
}
// Get the bootstrap SSH client. Do this early, so we know
// not to bother with any of the below if we can't finish the job.
client := ssh.DefaultClient
if client == nil {
// This should never happen: if we don't have OpenSSH, then
// go.crypto/ssh should be used with an auto-generated key.
return fmt.Errorf("no SSH client available")
}
privateKey, err := GenerateSystemSSHKey(env)
if err != nil {
return err
}
machineConfig := environs.NewBootstrapMachineConfig(privateKey)
fmt.Fprintln(ctx.GetStderr(), "Launching instance")
inst, hw, _, err := env.StartInstance(environs.StartInstanceParams{
Constraints: args.Constraints,
Tools: selectedTools,
MachineConfig: machineConfig,
Placement: args.Placement,
})
if err != nil {
return fmt.Errorf("cannot start bootstrap instance: %v", err)
}
fmt.Fprintf(ctx.GetStderr(), " - %s\n", inst.Id())
machineConfig.InstanceId = inst.Id()
machineConfig.HardwareCharacteristics = hw
err = bootstrap.SaveState(
env.Storage(),
&bootstrap.BootstrapState{
StateInstances: []instance.Id{inst.Id()},
})
if err != nil {
return fmt.Errorf("cannot save state: %v", err)
}
return FinishBootstrap(ctx, client, inst, machineConfig)
}
func (suite *StateSuite) TestLoadStateIntegratesWithSaveState(c *gc.C) {
storage := suite.newStorage(c)
state := bootstrap.BootstrapState{
StateInstances: []instance.Id{instance.Id("an-instance-id")},
}
err := bootstrap.SaveState(storage, &state)
c.Assert(err, gc.IsNil)
storedState, err := bootstrap.LoadState(storage)
c.Assert(err, gc.IsNil)
c.Check(*storedState, gc.DeepEquals, state)
}
func (suite *environSuite) TestStateServerInstances(c *gc.C) {
env := suite.makeEnviron()
tests := [][]instance.Id{{}, {"inst-0"}, {"inst-0", "inst-1"}}
for _, expected := range tests {
err := bootstrap.SaveState(env.Storage(), &bootstrap.BootstrapState{
StateInstances: expected,
})
c.Assert(err, gc.IsNil)
stateServerInstances, err := env.StateServerInstances()
c.Assert(err, gc.IsNil)
c.Assert(stateServerInstances, jc.SameContents, expected)
}
}
func (suite *StateSuite) TestSaveStateWritesStateFile(c *gc.C) {
stor := suite.newStorage(c)
state := bootstrap.BootstrapState{
StateInstances: []instance.Id{instance.Id("an-instance-id")},
}
marshaledState, err := goyaml.Marshal(state)
c.Assert(err, gc.IsNil)
err = bootstrap.SaveState(stor, &state)
c.Assert(err, gc.IsNil)
loadedState, err := storage.Get(stor, bootstrap.StateFile)
c.Assert(err, gc.IsNil)
content, err := ioutil.ReadAll(loadedState)
c.Assert(err, gc.IsNil)
c.Check(content, gc.DeepEquals, marshaledState)
}
func (suite *environSuite) TestStateInfo(c *gc.C) {
env := suite.makeEnviron()
hostname := "test"
input := `{"system_id": "system_id", "hostname": "` + hostname + `"}`
node := suite.testMAASObject.TestServer.NewNode(input)
testInstance := &maasInstance{maasObject: &node, environ: suite.makeEnviron()}
err := bootstrap.SaveState(
env.Storage(),
&bootstrap.BootstrapState{StateInstances: []instance.Id{testInstance.Id()}})
c.Assert(err, gc.IsNil)
stateInfo, apiInfo, err := env.StateInfo()
c.Assert(err, gc.IsNil)
cfg := env.Config()
statePortSuffix := fmt.Sprintf(":%d", cfg.StatePort())
apiPortSuffix := fmt.Sprintf(":%d", cfg.APIPort())
c.Assert(stateInfo.Addrs, gc.DeepEquals, []string{hostname + statePortSuffix})
c.Assert(apiInfo.Addrs, gc.DeepEquals, []string{hostname + apiPortSuffix})
}
func (e *environ) Bootstrap(ctx environs.BootstrapContext, args environs.BootstrapParams) error {
selectedTools, err := common.EnsureBootstrapTools(ctx, e, config.PreferredSeries(e.Config()), args.Constraints.Arch)
if err != nil {
return err
}
series := selectedTools.OneSeries()
defer delay()
if err := e.checkBroken("Bootstrap"); err != nil {
return err
}
network.InitializeFromConfig(e.Config())
password := e.Config().AdminSecret()
if password == "" {
return fmt.Errorf("admin-secret is required for bootstrap")
}
if _, ok := e.Config().CACert(); !ok {
return fmt.Errorf("no CA certificate in environment configuration")
}
logger.Infof("would pick tools from %s", selectedTools)
cfg, err := environs.BootstrapConfig(e.Config())
if err != nil {
return fmt.Errorf("cannot make bootstrap config: %v", err)
}
estate, err := e.state()
if err != nil {
return err
}
estate.mu.Lock()
defer estate.mu.Unlock()
if estate.bootstrapped {
return fmt.Errorf("environment is already bootstrapped")
}
estate.preferIPv6 = e.Config().PreferIPv6()
// Write the bootstrap file just like a normal provider. However
// we need to release the mutex for the save state to work, so regain
// it after the call.
estate.mu.Unlock()
instIds := []instance.Id{BootstrapInstanceId}
if err := bootstrap.SaveState(e.Storage(), &bootstrap.BootstrapState{StateInstances: instIds}); err != nil {
logger.Errorf("failed to save state instances: %v", err)
estate.mu.Lock() // otherwise defered unlock will fail
return err
}
estate.mu.Lock() // back at it
// Create an instance for the bootstrap node.
logger.Infof("creating bootstrap instance")
i := &dummyInstance{
id: BootstrapInstanceId,
addresses: network.NewAddresses("localhost"),
ports: make(map[network.Port]bool),
machineId: agent.BootstrapMachineId,
series: series,
firewallMode: e.Config().FirewallMode(),
state: estate,
stateServer: true,
}
estate.insts[i.id] = i
if e.ecfg().stateServer() {
// TODO(rog) factor out relevant code from cmd/jujud/bootstrap.go
// so that we can call it here.
info := stateInfo(estate.preferIPv6)
st, err := state.Initialize(info, cfg, mongo.DefaultDialOpts(), estate.statePolicy)
if err != nil {
panic(err)
}
if err := st.SetEnvironConstraints(args.Constraints); err != nil {
panic(err)
}
if err := st.SetAdminMongoPassword(utils.UserPasswordHash(password, utils.CompatSalt)); err != nil {
panic(err)
}
_, err = st.AddAdminUser(password)
if err != nil {
panic(err)
}
estate.apiServer, err = apiserver.NewServer(st, estate.apiListener, apiserver.ServerConfig{
Cert: []byte(testing.ServerCert),
Key: []byte(testing.ServerKey),
DataDir: DataDir,
LogDir: LogDir,
})
if err != nil {
panic(err)
}
estate.apiState = st
}
estate.bootstrapped = true
estate.ops <- OpBootstrap{Context: ctx, Env: e.name, Args: args}
return nil
}
// NewManualBootstrapEnviron wraps a LocalStorageEnviron with another which
// overrides the Bootstrap method; when Bootstrap is invoked, the specified
// host will be manually bootstrapped.
//
// InitUbuntuUser is expected to have been executed successfully against
// the host being bootstrapped.
func Bootstrap(args BootstrapArgs) (err error) {
if args.Host == "" {
return errors.New("host argument is empty")
}
if args.Environ == nil {
return errors.New("environ argument is nil")
}
if args.DataDir == "" {
return errors.New("data-dir argument is empty")
}
if args.Series == "" {
return errors.New("series argument is empty")
}
if args.HardwareCharacteristics == nil {
return errors.New("hardware characteristics argument is empty")
}
if len(args.PossibleTools) == 0 {
return errors.New("possible tools is empty")
}
provisioned, err := checkProvisioned(args.Host)
if err != nil {
return fmt.Errorf("failed to check provisioned status: %v", err)
}
if provisioned {
return ErrProvisioned
}
// Filter tools based on detected series/arch.
logger.Infof("Filtering possible tools: %v", args.PossibleTools)
possibleTools, err := args.PossibleTools.Match(tools.Filter{
Arch: *args.HardwareCharacteristics.Arch,
Series: args.Series,
})
if err != nil {
return err
}
// Store the state file. If provisioning fails, we'll remove the file.
logger.Infof("Saving bootstrap state file to bootstrap storage")
bootstrapStorage := args.Environ.Storage()
err = bootstrap.SaveState(
bootstrapStorage,
&bootstrap.BootstrapState{
StateInstances: []instance.Id{BootstrapInstanceId},
},
)
if err != nil {
return err
}
defer func() {
if err != nil {
logger.Errorf("bootstrapping failed, removing state file: %v", err)
bootstrapStorage.Remove(bootstrap.StateFile)
}
}()
// If the tools are on the machine already, get a file:// scheme tools URL.
tools := *possibleTools[0]
storageDir := args.Environ.StorageDir()
toolsStorageName := envtools.StorageName(tools.Version)
if url, _ := bootstrapStorage.URL(toolsStorageName); url == tools.URL {
tools.URL = fmt.Sprintf("file://%s/%s", storageDir, toolsStorageName)
}
// Add the local storage configuration.
agentEnv, err := localstorage.StoreConfig(args.Environ)
if err != nil {
return err
}
privateKey, err := common.GenerateSystemSSHKey(args.Environ)
if err != nil {
return err
}
// Finally, provision the machine agent.
mcfg := environs.NewBootstrapMachineConfig(privateKey)
mcfg.InstanceId = BootstrapInstanceId
mcfg.HardwareCharacteristics = args.HardwareCharacteristics
if args.DataDir != "" {
mcfg.DataDir = args.DataDir
}
mcfg.Tools = &tools
err = environs.FinishMachineConfig(mcfg, args.Environ.Config(), constraints.Value{})
if err != nil {
return err
}
for k, v := range agentEnv {
mcfg.AgentEnvironment[k] = v
}
return provisionMachineAgent(args.Host, mcfg, args.Context.GetStderr())
}
func (c *restoreCommand) Run(ctx *cmd.Context) error {
if c.showDescription {
fmt.Fprintf(ctx.Stdout, "%s\n", c.Info().Purpose)
return nil
}
if err := c.Log.Start(ctx); err != nil {
return err
}
agentConf, err := extractConfig(c.backupFile)
if err != nil {
return fmt.Errorf("cannot extract configuration from backup file: %v", err)
}
progress("extracted credentials from backup file")
store, err := configstore.Default()
if err != nil {
return err
}
cfg, _, err := environs.ConfigForName(c.EnvName, store)
if err != nil {
return err
}
env, err := rebootstrap(cfg, ctx, c.Constraints)
if err != nil {
return fmt.Errorf("cannot re-bootstrap environment: %v", err)
}
progress("connecting to newly bootstrapped instance")
var conn *juju.APIConn
// The state server backend may not be ready to accept logins so we retry.
// We'll do up to 8 retries over 2 minutes to give the server time to come up.
// Typically we expect only 1 retry will be needed.
attempt := utils.AttemptStrategy{Delay: 15 * time.Second, Min: 8}
for a := attempt.Start(); a.Next(); {
conn, err = juju.NewAPIConn(env, api.DefaultDialOpts())
if err == nil || errors.Cause(err).Error() != "EOF" {
break
}
progress("bootstrapped instance not ready - attempting to redial")
}
if err != nil {
return fmt.Errorf("cannot connect to bootstrap instance: %v", err)
}
progress("restoring bootstrap machine")
newInstId, machine0Addr, err := restoreBootstrapMachine(conn, c.backupFile, agentConf)
if err != nil {
return fmt.Errorf("cannot restore bootstrap machine: %v", err)
}
progress("restored bootstrap machine")
// Update the environ state to point to the new instance.
if err := bootstrap.SaveState(env.Storage(), &bootstrap.BootstrapState{
StateInstances: []instance.Id{newInstId},
}); err != nil {
return fmt.Errorf("cannot update environ bootstrap state storage: %v", err)
}
// Construct our own state info rather than using juju.NewConn so
// that we can avoid storage eventual-consistency issues
// (and it's faster too).
caCert, ok := cfg.CACert()
if !ok {
return fmt.Errorf("configuration has no CA certificate")
}
progress("opening state")
// We need to retry here to allow mongo to come up on the restored state server.
// The connection might succeed due to the mongo dial retries but there may still
// be a problem issuing database commands.
var st *state.State
for a := attempt.Start(); a.Next(); {
st, err = state.Open(&state.Info{
Info: mongo.Info{
Addrs: []string{fmt.Sprintf("%s:%d", machine0Addr, cfg.StatePort())},
CACert: caCert,
},
Tag: agentConf.Credentials.Tag,
Password: agentConf.Credentials.Password,
}, mongo.DefaultDialOpts(), environs.NewStatePolicy())
if err == nil {
break
}
progress("state server not ready - attempting to re-connect")
}
if err != nil {
return fmt.Errorf("cannot open state: %v", err)
}
progress("updating all machines")
if err := updateAllMachines(st, machine0Addr); err != nil {
return fmt.Errorf("cannot update machines: %v", err)
}
return nil
}
func (c *restoreCommand) Run(ctx *cmd.Context) error {
if c.showDescription {
fmt.Fprintf(ctx.Stdout, "%s\n", c.Info().Purpose)
return nil
}
if err := c.Log.Start(ctx); err != nil {
return err
}
agentConf, err := extractConfig(c.backupFile)
if err != nil {
return fmt.Errorf("cannot extract configuration from backup file: %v", err)
}
progress("extracted credentials from backup file")
store, err := configstore.Default()
if err != nil {
return err
}
cfg, _, err := environs.ConfigForName(c.EnvName, store)
if err != nil {
return err
}
env, err := rebootstrap(cfg, ctx, c.Constraints)
if err != nil {
return fmt.Errorf("cannot re-bootstrap environment: %v", err)
}
progress("connecting to newly bootstrapped instance")
conn, err := juju.NewAPIConn(env, api.DefaultDialOpts())
if err != nil {
return fmt.Errorf("cannot connect to bootstrap instance: %v", err)
}
progress("restoring bootstrap machine")
newInstId, machine0Addr, err := restoreBootstrapMachine(conn, c.backupFile, agentConf)
if err != nil {
return fmt.Errorf("cannot restore bootstrap machine: %v", err)
}
progress("restored bootstrap machine")
// Update the environ state to point to the new instance.
if err := bootstrap.SaveState(env.Storage(), &bootstrap.BootstrapState{
StateInstances: []instance.Id{newInstId},
}); err != nil {
return fmt.Errorf("cannot update environ bootstrap state storage: %v", err)
}
// Construct our own state info rather than using juju.NewConn so
// that we can avoid storage eventual-consistency issues
// (and it's faster too).
caCert, ok := cfg.CACert()
if !ok {
return fmt.Errorf("configuration has no CA certificate")
}
progress("opening state")
st, err := state.Open(&state.Info{
Info: mongo.Info{
Addrs: []string{fmt.Sprintf("%s:%d", machine0Addr, cfg.StatePort())},
CACert: caCert,
},
Tag: agentConf.Credentials.Tag,
Password: agentConf.Credentials.Password,
}, mongo.DefaultDialOpts(), environs.NewStatePolicy())
if err != nil {
return fmt.Errorf("cannot open state: %v", err)
}
progress("updating all machines")
if err := updateAllMachines(st, machine0Addr); err != nil {
return fmt.Errorf("cannot update machines: %v", err)
}
return nil
}