func (c *SetConstraintsCommand) Init(args []string) (err error) {
if c.ServiceName != "" && !names.IsService(c.ServiceName) {
return fmt.Errorf("invalid service name %q", c.ServiceName)
}
c.Constraints, err = constraints.Parse(args...)
return err
}
// AddService creates a new service, running the supplied charm, with the
// supplied name (which must be unique). If the charm defines peer relations,
// they will be created automatically.
func (st *State) AddService(name string, ch *Charm) (service *Service, err error) {
defer utils.ErrorContextf(&err, "cannot add service %q", name)
// Sanity checks.
if !names.IsService(name) {
return nil, fmt.Errorf("invalid name")
}
if ch == nil {
return nil, fmt.Errorf("charm is nil")
}
if exists, err := isNotDead(st.services, name); err != nil {
return nil, err
} else if exists {
return nil, fmt.Errorf("service already exists")
}
// Create the service addition operations.
peers := ch.Meta().Peers
svcDoc := &serviceDoc{
Name: name,
Series: ch.URL().Series,
Subordinate: ch.Meta().Subordinate,
CharmURL: ch.URL(),
RelationCount: len(peers),
Life: Alive,
}
svc := newService(st, svcDoc)
ops := []txn.Op{
createConstraintsOp(st, svc.globalKey(), constraints.Value{}),
createSettingsOp(st, svc.settingsKey(), nil),
{
C: st.settingsrefs.Name,
Id: svc.settingsKey(),
Assert: txn.DocMissing,
Insert: settingsRefsDoc{1},
}, {
C: st.services.Name,
Id: name,
Assert: txn.DocMissing,
Insert: svcDoc,
}}
// Collect peer relation addition operations.
peerOps, err := st.addPeerRelationsOps(name, peers)
if err != nil {
return nil, err
}
ops = append(ops, peerOps...)
// Run the transaction; happily, there's never any reason to retry,
// because all the possible failed assertions imply that the service
// already exists.
if err := st.runTransaction(ops); err == txn.ErrAborted {
return nil, fmt.Errorf("service already exists")
} else if err != nil {
return nil, err
}
// Refresh to pick the txn-revno.
if err = svc.Refresh(); err != nil {
return nil, err
}
return svc, nil
}
func (c *GetConstraintsCommand) Init(args []string) error {
if len(args) > 0 {
if !names.IsService(args[0]) {
return fmt.Errorf("invalid service name %q", args[0])
}
c.ServiceName, args = args[0], args[1:]
}
return cmd.CheckEmpty(args)
}
func (c *DestroyServiceCommand) Init(args []string) error {
if len(args) == 0 {
return fmt.Errorf("no service specified")
}
if !names.IsService(args[0]) {
return fmt.Errorf("invalid service name %q", args[0])
}
c.ServiceName, args = args[0], args[1:]
return cmd.CheckEmpty(args)
}
// Service returns a service state by name.
func (st *State) Service(name string) (service *Service, err error) {
if !names.IsService(name) {
return nil, fmt.Errorf("%q is not a valid service name", name)
}
sdoc := &serviceDoc{}
sel := D{{"_id", name}}
err = st.services.Find(sel).One(sdoc)
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("service %q", name)
}
if err != nil {
return nil, fmt.Errorf("cannot get service %q: %v", name, err)
}
return newService(st, sdoc), nil
}
func (c *UpgradeCharmCommand) Init(args []string) error {
switch len(args) {
case 1:
if !names.IsService(args[0]) {
return fmt.Errorf("invalid service name %q", args[0])
}
c.ServiceName = args[0]
case 0:
return errors.New("no service specified")
default:
return cmd.CheckEmpty(args[1:])
}
if c.SwitchURL != "" && c.Revision != -1 {
return fmt.Errorf("--switch and --revision are mutually exclusive")
}
return nil
}
func (s *serviceSuite) TestServiceNameFormats(c *gc.C) {
assertService := func(s string, expect bool) {
c.Assert(names.IsService(s), gc.Equals, expect)
// Check that anything that is considered a valid service name
// is also (in)valid if a(n) (in)valid unit designator is added
// to it.
c.Assert(names.IsUnit(s+"/0"), gc.Equals, expect)
c.Assert(names.IsUnit(s+"/99"), gc.Equals, expect)
c.Assert(names.IsUnit(s+"/-1"), gc.Equals, false)
c.Assert(names.IsUnit(s+"/blah"), gc.Equals, false)
c.Assert(names.IsUnit(s+"/"), gc.Equals, false)
}
for i, test := range serviceNameTests {
c.Logf("test %d: %q", i, test.pattern)
assertService(test.pattern, test.valid)
}
}
func (c *DeployCommand) Init(args []string) error {
switch len(args) {
case 2:
if !names.IsService(args[1]) {
return fmt.Errorf("invalid service name %q", args[1])
}
c.ServiceName = args[1]
fallthrough
case 1:
if _, err := charm.InferURL(args[0], "fake"); err != nil {
return fmt.Errorf("invalid charm name %q", args[0])
}
c.CharmName = args[0]
case 0:
return errors.New("no charm specified")
default:
return cmd.CheckEmpty(args[2:])
}
return c.UnitCommandBase.Init(args)
}
