func (s *EnvironmentVersionSuite) TestSuccess(c *gc.C) {
vs := "1.22.1"
s.fake.agentVersion = vs
v, err := modelcmd.GetEnvironmentVersion(s.fake)
c.Assert(err, jc.ErrorIsNil)
c.Assert(v.Compare(version.MustParse(vs)), gc.Equals, 0)
}
func (s *EnvironmentVersionSuite) TestInvalidVersion(c *gc.C) {
s.fake.agentVersion = "a.b.c"
_, err := modelcmd.GetEnvironmentVersion(s.fake)
c.Assert(err, gc.ErrorMatches, "unable to parse model version: .+")
}
func (s *EnvironmentVersionSuite) TestInvalidVersionType(c *gc.C) {
s.fake.agentVersion = 99
_, err := modelcmd.GetEnvironmentVersion(s.fake)
c.Assert(err, gc.ErrorMatches, "invalid model version type in config")
}
func (s *EnvironmentVersionSuite) TestNoVersion(c *gc.C) {
_, err := modelcmd.GetEnvironmentVersion(s.fake)
c.Assert(err, gc.ErrorMatches, "version not found in model config")
}
func (s *EnvironmentVersionSuite) TestApiCallFails(c *gc.C) {
s.fake.err = errors.New("boom")
_, err := modelcmd.GetEnvironmentVersion(s.fake)
c.Assert(err, gc.ErrorMatches, "unable to retrieve model config: boom")
}
func (c *addCommand) Run(ctx *cmd.Context) error {
client, err := c.getClientAPI()
if err != nil {
return errors.Trace(err)
}
defer client.Close()
var machineManager MachineManagerAPI
if len(c.Disks) > 0 {
machineManager, err = c.getMachineManagerAPI()
if err != nil {
return errors.Trace(err)
}
defer machineManager.Close()
if machineManager.BestAPIVersion() < 1 {
return errors.New("cannot add machines with disks: not supported by the API server")
}
}
logger.Infof("load config")
var config *config.Config
if defaultStore, err := configstore.Default(); err != nil {
return err
} else if config, err = c.Config(defaultStore, client); err != nil {
return err
}
if c.Placement != nil && c.Placement.Scope == "ssh" {
logger.Infof("manual provisioning")
args := manual.ProvisionMachineArgs{
Host: c.Placement.Directive,
Client: client,
Stdin: ctx.Stdin,
Stdout: ctx.Stdout,
Stderr: ctx.Stderr,
UpdateBehavior: ¶ms.UpdateBehavior{
config.EnableOSRefreshUpdate(),
config.EnableOSUpgrade(),
},
}
machineId, err := manualProvisioner(args)
if err == nil {
ctx.Infof("created machine %v", machineId)
}
return err
}
logger.Infof("model provisioning")
if c.Placement != nil && c.Placement.Scope == "model-uuid" {
c.Placement.Scope = client.ModelUUID()
}
if c.Placement != nil && c.Placement.Scope == instance.MachineScope {
// It does not make sense to add-machine <id>.
return fmt.Errorf("machine-id cannot be specified when adding machines")
}
jobs := []multiwatcher.MachineJob{multiwatcher.JobHostUnits}
envVersion, err := modelcmd.GetEnvironmentVersion(client)
if err != nil {
return err
}
// Servers before 1.21-alpha2 don't have the networker so don't
// try to use JobManageNetworking with them.
//
// In case of MAAS and Joyent JobManageNetworking is not added
// to ensure the non-intrusive start of a networker like above
// for the manual provisioning. See this related joyent bug
// http://pad.lv/1401423
if envVersion.Compare(version.MustParse("1.21-alpha2")) >= 0 &&
config.Type() != provider.MAAS &&
config.Type() != provider.Joyent {
jobs = append(jobs, multiwatcher.JobManageNetworking)
}
machineParams := params.AddMachineParams{
Placement: c.Placement,
Series: c.Series,
Constraints: c.Constraints,
Jobs: jobs,
Disks: c.Disks,
}
machines := make([]params.AddMachineParams, c.NumMachines)
for i := 0; i < c.NumMachines; i++ {
machines[i] = machineParams
}
var results []params.AddMachinesResult
// If storage is specified, we attempt to use a new API on the service facade.
if len(c.Disks) > 0 {
results, err = machineManager.AddMachines(machines)
} else {
results, err = client.AddMachines(machines)
}
if params.IsCodeOperationBlocked(err) {
return block.ProcessBlockedError(err, block.BlockChange)
}
if err != nil {
return errors.Trace(err)
}
errs := []error{}
for _, machineInfo := range results {
if machineInfo.Error != nil {
errs = append(errs, machineInfo.Error)
continue
}
machineId := machineInfo.Machine
if names.IsContainerMachine(machineId) {
ctx.Infof("created container %v", machineId)
} else {
ctx.Infof("created machine %v", machineId)
}
}
if len(errs) == 1 {
fmt.Fprintf(ctx.Stderr, "failed to create 1 machine\n")
return errs[0]
}
if len(errs) > 1 {
fmt.Fprintf(ctx.Stderr, "failed to create %d machines\n", len(errs))
returnErr := []string{}
for _, e := range errs {
returnErr = append(returnErr, e.Error())
}
return errors.New(strings.Join(returnErr, ", "))
}
return nil
}