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)
}
func (c *ResolvedCommand) Init(args []string) error {
if len(args) > 0 {
c.UnitName = args[0]
if !state.IsUnitName(c.UnitName) {
return fmt.Errorf("invalid unit name %q", c.UnitName)
}
args = args[1:]
} else {
return fmt.Errorf("no unit specified")
}
return cmd.CheckEmpty(args)
}
func (c *DestroyUnitCommand) Init(args []string) error {
c.UnitNames = args
if len(c.UnitNames) == 0 {
return errors.New("no units specified")
}
for _, name := range c.UnitNames {
if !state.IsUnitName(name) {
return fmt.Errorf("invalid unit name %q", name)
}
}
return nil
}
// Init initializes the command for running.
func (a *UnitAgent) Init(args []string) error {
if a.UnitName == "" {
return requiredError("unit-name")
}
if !state.IsUnitName(a.UnitName) {
return fmt.Errorf(`--unit-name option expects "<service>/<n>" argument`)
}
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 *UnitAgent) Init(f *gnuflag.FlagSet, args []string) error {
a.Conf.addFlags(f)
f.StringVar(&a.UnitName, "unit-name", "", "name of the unit to run")
if err := f.Parse(true, args); err != nil {
return err
}
if a.UnitName == "" {
return requiredError("unit-name")
}
if !state.IsUnitName(a.UnitName) {
return fmt.Errorf(`--unit-name option expects "<service>/<n>" argument`)
}
return a.Conf.checkArgs(f.Args())
}
func (c *DestroyUnitCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
if err := f.Parse(true, args); err != nil {
return err
}
c.UnitNames = f.Args()
if len(c.UnitNames) == 0 {
return errors.New("no units specified")
}
for _, name := range c.UnitNames {
if !state.IsUnitName(name) {
return fmt.Errorf("invalid unit name: %q", name)
}
}
return nil
}
func (ctx *SimpleContext) deployedUnitsUpstartJobs() (map[string]string, error) {
fis, err := ioutil.ReadDir(ctx.initDir)
if err != nil {
return nil, err
}
installed := make(map[string]string)
for _, fi := range fis {
if groups := deployedRe.FindStringSubmatch(fi.Name()); len(groups) == 4 {
unitName := groups[2] + "/" + groups[3]
if !state.IsUnitName(unitName) {
continue
}
installed[unitName] = groups[1]
}
}
return installed, nil
}
func (c *ResolvedCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
f.BoolVar(&c.Retry, "r", false, "re-execute failed hooks")
f.BoolVar(&c.Retry, "retry", false, "")
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if len(args) > 0 {
c.UnitName = args[0]
if !state.IsUnitName(c.UnitName) {
return fmt.Errorf("invalid unit name %q", c.UnitName)
}
args = args[1:]
} else {
return fmt.Errorf("no unit specified")
}
return cmd.CheckEmpty(args)
}
func (mgr *SimpleManager) DeployedUnits() ([]string, error) {
fis, err := ioutil.ReadDir(mgr.InitDir)
if err != nil {
return nil, err
}
var installed []string
for _, fi := range fis {
if groups := deployedRe.FindStringSubmatch(fi.Name()); len(groups) == 4 {
if groups[1] != mgr.StateInfo.EntityName {
continue
}
unitName := groups[2] + "/" + groups[3]
if !state.IsUnitName(unitName) {
continue
}
installed = append(installed, unitName)
}
}
return installed, 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)
}