func (*StateSuite) TestNameChecks(c *C) {
assertService := func(s string, expect bool) {
c.Assert(state.IsServiceName(s), Equals, expect)
c.Assert(state.IsUnitName(s+"/0"), Equals, expect)
c.Assert(state.IsUnitName(s+"/99"), Equals, expect)
c.Assert(state.IsUnitName(s+"/-1"), Equals, false)
c.Assert(state.IsUnitName(s+"/blah"), Equals, false)
}
assertService("", false)
assertService("33", false)
assertService("wordpress", true)
assertService("w0rd-pre55", true)
assertService("foo2", true)
assertService("foo-2", false)
assertService("foo-2foo", true)
assertMachine := func(s string, expect bool) {
c.Assert(state.IsMachineId(s), Equals, expect)
}
assertMachine("0", true)
assertMachine("1", true)
assertMachine("1000001", true)
assertMachine("01", false)
assertMachine("-1", false)
assertMachine("", false)
assertMachine("cantankerous", false)
}
// Init initializes the command for running.
func (a *MachineAgent) Init(args []string) error {
if !state.IsMachineId(a.MachineId) {
return fmt.Errorf("--machine-id option must be set, and expects a non-negative integer")
}
if err := a.Conf.checkArgs(args); err != nil {
return err
}
a.runner = worker.NewRunner(isFatal, moreImportant)
return nil
}
// Init initializes the command for running.
func (a *MachineAgent) Init(f *gnuflag.FlagSet, args []string) error {
a.Conf.addFlags(f)
f.StringVar(&a.MachineId, "machine-id", "", "id of the machine to run")
if err := f.Parse(true, args); err != nil {
return err
}
if !state.IsMachineId(a.MachineId) {
return fmt.Errorf("--machine-id option must be set, and expects a non-negative integer")
}
return a.Conf.checkArgs(f.Args())
}
func verifyConfig(cfg *MachineConfig) (err error) {
defer trivial.ErrorContextf(&err, "invalid machine configuration")
if !state.IsMachineId(cfg.MachineId) {
return fmt.Errorf("invalid machine id")
}
if cfg.ProviderType == "" {
return fmt.Errorf("missing provider type")
}
if cfg.DataDir == "" {
return fmt.Errorf("missing var directory")
}
if cfg.Tools == nil {
return fmt.Errorf("missing tools")
}
if cfg.Tools.URL == "" {
return fmt.Errorf("missing tools URL")
}
if cfg.StateInfo == nil {
return fmt.Errorf("missing state info")
}
if len(cfg.StateInfo.CACert) == 0 {
return fmt.Errorf("missing CA certificate")
}
if cfg.StateServer {
if cfg.InstanceIdAccessor == "" {
return fmt.Errorf("missing instance id accessor")
}
if cfg.Config == nil {
return fmt.Errorf("missing environment configuration")
}
if cfg.StateInfo.EntityName != "" {
return fmt.Errorf("entity name must be blank when starting a state server")
}
if len(cfg.StateServerCert) == 0 {
return fmt.Errorf("missing state server certificate")
}
if len(cfg.StateServerKey) == 0 {
return fmt.Errorf("missing state server private key")
}
} else {
if len(cfg.StateInfo.Addrs) == 0 {
return fmt.Errorf("missing state hosts")
}
if cfg.StateInfo.EntityName != state.MachineEntityName(cfg.MachineId) {
return fmt.Errorf("entity name must match started machine")
}
}
for _, r := range cfg.StateInfo.Password {
if r == '\'' || r == '\\' || r < 32 {
return fmt.Errorf("password has disallowed characters")
}
}
return nil
}
func (c *DestroyMachineCommand) Init(args []string) error {
if len(args) == 0 {
return fmt.Errorf("no machines specified")
}
for _, id := range args {
if !state.IsMachineId(id) {
return fmt.Errorf("invalid machine id %q", id)
}
}
c.MachineIds = args
return nil
}
func (c *SSHCommon) hostFromTarget(target string) (string, error) {
// is the target the id of a machine ?
if state.IsMachineId(target) {
log.Infof("looking up address for machine %s...", target)
// TODO(dfc) maybe we should have machine.PublicAddress() ?
return c.machinePublicAddress(target)
}
// maybe the target is a unit ?
if state.IsUnitName(target) {
log.Infof("looking up address for unit %q...", c.Target)
unit, err := c.State.Unit(target)
if err != nil {
return "", err
}
addr, ok := unit.PublicAddress()
if !ok {
return "", fmt.Errorf("unit %q has no public address", unit)
}
return addr, nil
}
return "", fmt.Errorf("unknown unit or machine %q", target)
}
func verifyConfig(cfg *MachineConfig) (err error) {
defer utils.ErrorContextf(&err, "invalid machine configuration")
if !state.IsMachineId(cfg.MachineId) {
return fmt.Errorf("invalid machine id")
}
if cfg.DataDir == "" {
return fmt.Errorf("missing var directory")
}
if cfg.Tools == nil {
return fmt.Errorf("missing tools")
}
if cfg.Tools.URL == "" {
return fmt.Errorf("missing tools URL")
}
if cfg.StateInfo == nil {
return fmt.Errorf("missing state info")
}
if len(cfg.StateInfo.CACert) == 0 {
return fmt.Errorf("missing CA certificate")
}
if cfg.APIInfo == nil {
return fmt.Errorf("missing API info")
}
if len(cfg.APIInfo.CACert) == 0 {
return fmt.Errorf("missing API CA certificate")
}
if cfg.ProviderType == "" {
return fmt.Errorf("missing provider type")
}
if cfg.StateServer {
if cfg.Config == nil {
return fmt.Errorf("missing environment configuration")
}
if cfg.StateInfo.Tag != "" {
return fmt.Errorf("entity tag must be blank when starting a state server")
}
if cfg.APIInfo.Tag != "" {
return fmt.Errorf("entity tag must be blank when starting a state server")
}
if len(cfg.StateServerCert) == 0 {
return fmt.Errorf("missing state server certificate")
}
if len(cfg.StateServerKey) == 0 {
return fmt.Errorf("missing state server private key")
}
if cfg.StatePort == 0 {
return fmt.Errorf("missing state port")
}
if cfg.APIPort == 0 {
return fmt.Errorf("missing API port")
}
} else {
if len(cfg.StateInfo.Addrs) == 0 {
return fmt.Errorf("missing state hosts")
}
if cfg.StateInfo.Tag != state.MachineTag(cfg.MachineId) {
return fmt.Errorf("entity tag must match started machine")
}
if len(cfg.APIInfo.Addrs) == 0 {
return fmt.Errorf("missing API hosts")
}
if cfg.APIInfo.Tag != state.MachineTag(cfg.MachineId) {
return fmt.Errorf("entity tag must match started machine")
}
}
if cfg.MachineNonce == "" {
return fmt.Errorf("missing machine nonce")
}
return nil
}
// AddUnits starts n units of the given service and allocates machines
// to them as necessary.
func (conn *Conn) AddUnits(svc *state.Service, n int, machineIdSpec string) ([]*state.Unit, error) {
units := make([]*state.Unit, n)
// Hard code for now till we implement a different approach.
policy := state.AssignCleanEmpty
// TODO what do we do if we fail half-way through this process?
for i := 0; i < n; i++ {
unit, err := svc.AddUnit()
if err != nil {
return nil, fmt.Errorf("cannot add unit %d/%d to service %q: %v", i+1, n, svc.Name(), err)
}
if machineIdSpec != "" {
if n != 1 {
return nil, fmt.Errorf("cannot add multiple units of service %q to a single machine", svc.Name())
}
// machineIdSpec may be an existing machine or container, eg 3/lxc/2
// or a new container on a machine, eg lxc:3
mid := machineIdSpec
var containerType instance.ContainerType
specParts := strings.Split(machineIdSpec, ":")
if len(specParts) > 1 {
firstPart := specParts[0]
var err error
if containerType, err = instance.ParseSupportedContainerType(firstPart); err == nil {
mid = strings.Join(specParts[1:], "/")
} else {
mid = machineIdSpec
}
}
if !state.IsMachineId(mid) {
return nil, fmt.Errorf("invalid force machine id %q", mid)
}
var err error
var m *state.Machine
// If a container is to be used, create it.
if containerType != "" {
params := state.AddMachineParams{
Series: unit.Series(),
ParentId: mid,
ContainerType: containerType,
Jobs: []state.MachineJob{state.JobHostUnits},
}
m, err = conn.State.AddMachineWithConstraints(¶ms)
} else {
m, err = conn.State.Machine(mid)
}
if err != nil {
return nil, fmt.Errorf("cannot assign unit %q to machine: %v", unit.Name(), err)
}
err = unit.AssignToMachine(m)
if err != nil {
return nil, err
}
} else if err := conn.State.AssignUnit(unit, policy); err != nil {
return nil, err
}
units[i] = unit
}
return units, nil
}