state: check unit/service name validity

state/state.go

 // The state package enables reading, observing, and changing
 // the state stored in MongoDB of a whole environment
 // managed by juju.
 package state
 
 import (
         "fmt"
         "labix.org/v2/mgo"
         "labix.org/v2/mgo/bson"
         "labix.org/v2/mgo/txn"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/state/presence"
         "launchpad.net/juju-core/state/watcher"
         "launchpad.net/juju-core/trivial"
         "launchpad.net/juju-core/version"
         "net/url"
+        "regexp"
 )
 
 type D []bson.DocElem
 
 // Tools describes a particular set of juju tools and where to find them.
 type Tools struct {
         version.Binary
         URL string
 }
 
+var (
+        validService = regexp.MustCompile("^[a-z][a-z0-9]*(-[a-z0-9]*[a-z][a-z0-9]*)*$")
+        validUnit    = regexp.MustCompile("^[a-z][a-z0-9]*(-[a-z0-9]*[a-z][a-z0-9]*)*/[0-9]+$")
+)
+
+// IsServiceName returns true if name is a valid service name.

[niemeyer, 2012/09/20 10:35:34]

s/true if/whether/ (both are of course right.. it's just upstream Go convention)

[fwereade, 2012/09/20 10:41:32]

Done.

+func IsServiceName(name string) bool {
+        return validService.MatchString(name)
+}
+
+// IsUnitName returns true if name is a valid service name.

[niemeyer, 2012/09/20 10:35:34]

s/true if/whether/
s/service/unit/

[fwereade, 2012/09/20 10:41:32]

Done.

+func IsUnitName(name string) bool {
+        return validUnit.MatchString(name)
+}
+
 // State represents the state of an environment
 // managed by juju.
 type State struct {
         db        *mgo.Database
         charms    *mgo.Collection
         machines  *mgo.Collection
         relations *mgo.Collection
         services  *mgo.Collection
         settings  *mgo.Collection
         units     *mgo.Collection
@@ skipping 131 matching lines @@
         if err != nil {
                 return nil, fmt.Errorf("cannot get charm %q: %v", curl, err)
         }
 
         return newCharm(s, cdoc)
 }
 
 // AddService creates a new service state with the given unique name
 // and the charm state.
 func (s *State) AddService(name string, ch *Charm) (service *Service, err error) {
+        if !IsServiceName(name) {
+                return nil, fmt.Errorf("%q is not a valid service name", name)
+        }
         sdoc := &serviceDoc{
                 Name:     name,
                 CharmURL: ch.URL(),
                 Life:     Alive,
         }
         ops := []txn.Op{{
                 C:      s.services.Name,
                 Id:     name,
                 Assert: txn.DocMissing,
                 Insert: sdoc,
@@ skipping 51 matching lines @@
         }}
         if err := s.runner.Run(ops, "", nil); err != nil {
                 // If aborted, the service is either dead or recreated.
                 return onAbort(err, nil)
         }
         return nil
 }
 
 // Service returns a service state by name.
 func (s *State) Service(name string) (service *Service, err error) {
+        if !IsServiceName(name) {
+                return nil, fmt.Errorf("%q is not a valid service name", name)
+        }
         sdoc := &serviceDoc{}
         sel := D{{"_id", name}}
         err = s.services.Find(sel).One(sdoc)
         if err != nil {
                 return nil, fmt.Errorf("cannot get service %q: %v", name, err)
         }
         return newService(s, sdoc), nil
 }
 
 // AllServices returns all deployed services in the environment.
@@ skipping 92 matching lines @@
         }}
         if err := s.runner.Run(ops, "", nil); err != nil {
                 // If aborted, the relation is either dead or recreated.
                 return onAbort(err, nil)
         }
         return nil
 }
 
 // Unit returns a unit by name.
 func (s *State) Unit(name string) (*Unit, error) {
+        if !IsUnitName(name) {
+                return nil, fmt.Errorf("%q is not a valid unit name", name)
+        }
         doc := unitDoc{}
         err := s.units.FindId(name).One(&doc)
         if err != nil {
                 return nil, fmt.Errorf("cannot get unit %q: %v", name, err)
         }
         return newUnit(s, &doc), nil
 }
 
 // StartSync forces watchers to resynchronize their state with the
 // database immediately. This will happen periodically automatically.
 func (s *State) StartSync() {
         s.watcher.StartSync()
         s.pwatcher.StartSync()
 }
 
 // Sync forces watchers to resynchronize their state with the
 // database immediately, and waits until all events are known.
 func (s *State) Sync() {
         s.watcher.Sync()
         s.pwatcher.Sync()
 }