mstate: removing a node removes associated nodes.

mstate/service.go

 package mstate
 
 import (
         "errors"
         "fmt"
         "labix.org/v2/mgo/bson"
         "launchpad.net/juju-core/charm"
-        "launchpad.net/juju-core/mstate/life"
         "strconv"
 )
 
 // Service represents the state of a service.
 type Service struct {
         st   *State
         name string
 }
 
 // serviceDoc represents the internal state of a service in MongoDB.
 type serviceDoc struct {
-        Name      string `bson:"_id"`
-        CharmURL  *charm.URL
-        LifeCycle life.Cycle
+        Name     string `bson:"_id"`
+        CharmURL *charm.URL
+        Life     Life
 }
 
 // Name returns the service name.
 func (s *Service) Name() string {
         return s.name
 }
 
 // CharmURL returns the charm URL this service is supposed to use.
 func (s *Service) CharmURL() (url *charm.URL, err error) {
         sdoc := &serviceDoc{}
-        sel := bson.D{{"_id", s.name}, {"lifecycle", life.Alive}}
+        sel := bson.D{{"_id", s.name}, {"life", Alive}}
         err = s.st.services.Find(sel).One(sdoc)
         if err != nil {
                 return nil, fmt.Errorf("can't get the charm URL of service %q: %v", s, err)
         }
         return sdoc.CharmURL, nil
 }
 
 // SetCharmURL changes the charm URL for the service.
 func (s *Service) SetCharmURL(url *charm.URL) (err error) {
         change := bson.D{{"$set", bson.D{{"charmurl", url}}}}
@@ skipping 27 matching lines @@
         name := s.name + "/" + strconv.Itoa(id)
         return name, nil
 }
 
 // addUnit adds the named unit, which is part of unitSet.
 func (s *Service) addUnit(name string, principal string) (*Unit, error) {
         udoc := unitDoc{
                 Name:      name,
                 Service:   s.name,
                 Principal: principal,
-                LifeCycle: life.Alive,
+                Life:      Alive,
         }
         err := s.st.units.Insert(udoc)
         if err != nil {
                 return nil, fmt.Errorf("can't add unit to service %q", s)
         }
         return newUnit(s.st, &udoc), nil
 }
 
 // AddUnit adds a new principal unit to the service.
 func (s *Service) AddUnit() (unit *Unit, err error) {
@@ skipping 25 matching lines @@
                 return nil, errors.New("a subordinate unit must be added to a principal unit")
         }
         name, err := s.newUnitName()
         if err != nil {
                 return nil, fmt.Errorf("can't add unit to service %q: %v", err)
         }
         return s.addUnit(name, principal.Name())
 }
 
 // RemoveUnit removes the given unit from s.
-func (s *Service) RemoveUnit(unit *Unit) (err error) {
+func (s *Service) RemoveUnit(unit *Unit) error {
         sel := bson.D{
                 {"_id", unit.Name()},
                 {"service", s.name},
-                {"lifecycle", life.Alive},
+                {"life", Alive},
         }
-        change := bson.D{{"$set", bson.D{{"lifecycle", life.Dying}, {"machineid", nil}}}}

[niemeyer, 2012/07/03 21:16:16]

This change looks a bit suspect in theory. It seems sane to keep the dying
resource assigned to the machine it was originally, because it won't magically
pop *out* of the machine before it is actually dead.  I suggest we have a team
call tomorrow to consider it, having in mind the lifecycle proposal, so that we
can establish a best-practice approach for similar situations.

-        err = s.st.units.Update(sel, change)
+        change := bson.D{{"$set", bson.D{{"life", Dying}, {"machineid", nil}}}}
+        err := s.st.units.Update(sel, change)
         if err != nil {
                 return fmt.Errorf("can't remove unit %q: %v", unit, err)
         }
         return nil
 }
 
 func (s *Service) unitDoc(name string) (*unitDoc, error) {
         udoc := &unitDoc{}
         sel := bson.D{
                 {"_id", name},
                 {"service", s.name},
-                {"lifecycle", life.Alive},
+                {"life", Alive},
         }
         err := s.st.units.Find(sel).One(udoc)
         if err != nil {
                 return nil, err
         }
         return udoc, nil
 }
 
 // Unit returns the service's unit with name.
 func (s *Service) Unit(name string) (*Unit, error) {
         udoc, err := s.unitDoc(name)
         if err != nil {
                 return nil, fmt.Errorf("can't get unit %q from service %q: %v", name, s.name, err)
         }
         return newUnit(s.st, udoc), nil
 }
 
 // AllUnits returns all units of the service.
 func (s *Service) AllUnits() (units []*Unit, err error) {
         docs := []unitDoc{}
-        sel := bson.D{{"service", s.name}, {"lifecycle", life.Alive}}
+        sel := bson.D{{"service", s.name}, {"life", Alive}}
         err = s.st.units.Find(sel).All(&docs)
         if err != nil {
                 return nil, fmt.Errorf("can't get all units from service %q: %v", err)
         }
         for i := range docs {
                 units = append(units, newUnit(s.st, &docs[i]))
         }
         return units, nil
 }