Implementation of the charm state.

state/state.go

 // launchpad.net/juju/state
 //
 // Copyright (c) 2011-2012 Canonical Ltd.
 
 // The state package enables reading, observing, and changing
 // the state stored in ZooKeeper of a whole environment
 // managed by juju.
 package state
 
 import (
         "fmt"
         "launchpad.net/goyaml"
         "launchpad.net/gozk/zookeeper"
         "launchpad.net/juju/go/charm"
+        "net/url"
         "strings"
 )
 
 // State represents the state of an environment
 // managed by juju.
 type State struct {
         zk *zookeeper.Conn
 }
 
-// Add machine creates a new machine.
+// AddMachine creates a new machine state.
 func (s *State) AddMachine() (*Machine, error) {
         path, err := s.zk.Create("/machines/machine-", "", zookeeper.SEQUENCE, zkPermAll)
         if err != nil {
                 return nil, err
         }
         key := strings.Split(path, "/")[2]
         addMachine := func(t *topology) error {
                 return t.AddMachine(key)
         }
         if err = retryTopologyChange(s.zk, addMachine); err != nil {
                 return nil, err
         }
         return &Machine{s.zk, key}, nil
 }
 
-// AddCharm registers metadata about the provided Charm.

[niemeyer, 2012/02/23 14:57:46]

Please improve this comment.

[TheMue, 2012/02/24 10:38:38]

Done.

-func (s *State) AddCharm(charmURL *charm.URL, ch charm.Charm, url string) (*Charm, error) {

[niemeyer, 2012/02/23 14:57:46]

(ch charm.Charm, curl *charm.URL, bundleUrl string), in this order please.

[TheMue, 2012/02/24 10:38:38]

Done.

[niemeyer, 2012/02/27 15:58:10]

Half Done. Please fix the bundle URL argument too.

+// AddCharm adds the ch charm with curl to the state.
+// bundleUrl must be set to a URL where the bundle for ch
+// may be downloaded from.
+// On success the newly added charm state is returned.
+func (s *State) AddCharm(ch charm.Charm, curl *charm.URL, bundleURL *url.URL) (*Charm, error) {
         data := &charmData{
-                Meta:   ch.Meta(),
-                Config: ch.Config(),
-                URL:    url,
+                Meta:      ch.Meta(),
+                Config:    ch.Config(),
+                BundleURL: bundleURL.String(),
         }
         yaml, err := goyaml.Marshal(data)
         if err != nil {
                 return nil, err
         }
-        _, err = s.zk.Create(charmPath(charmURL), string(yaml), 0, zkPermAll)
-        if err != nil {
-                return nil, err
-        }
-        return newCharm(s.zk, charmURL, data)
+        path, err := charmPath(curl)
+        if err != nil {
+                return nil, err
+        }
+        _, err = s.zk.Create(path, string(yaml), 0, zkPermAll)
+        if err != nil {
+                return nil, err
+        }
+        return newCharm(s, curl, data)
 }
 
 // Charm returns a charm by the given id.
-func (s *State) Charm(charmURL *charm.URL) (*Charm, error) {

[niemeyer, 2012/02/23 14:57:46]

s/charmURL/curl/

[TheMue, 2012/02/24 10:38:38]

Done.

-        return readCharm(s.zk, charmURL)

[niemeyer, 2012/02/23 14:57:46]

We shouldn't need this helper function, unless there's somewhere we really have
no access to a *State that must read a charm directly from zk, which I don't
think is the case.

The content of readCharm should be inlined here.

[TheMue, 2012/02/24 10:38:38]

Done.

-}
-
-// AddService creates a new service with the given unique name
+func (s *State) Charm(curl *charm.URL) (*Charm, error) {
+        path, err := charmPath(curl)
+        if err != nil {
+                return nil, err
+        }
+        yaml, _, err := s.zk.Get(path)
+        if err == zookeeper.ZNONODE {
+                return nil, fmt.Errorf("charm not found: %q", curl)
+        }
+        if err != nil {
+                return nil, err
+        }
+        data := &charmData{}
+        if err := goyaml.Unmarshal([]byte(yaml), data); err != nil {
+                return nil, err
+        }
+        return newCharm(s, curl, data)
+}
+
+// AddService creates a new service state with the given unique name
 // and the charm state.
 func (s *State) AddService(name string, ch *Charm) (*Service, error) {
         details := map[string]interface{}{"charm": ch.URL().String()}
         yaml, err := goyaml.Marshal(details)
         if err != nil {
                 return nil, err
         }
         path, err := s.zk.Create("/services/service-", string(yaml), zookeeper.SEQUENCE, zkPermAll)
         if err != nil {
                 return nil, err
         }
         key := strings.Split(path, "/")[2]
-        service := &Service{s.zk, key, name}
+        service := &Service{s, key, name}
         // Create an empty configuration node.
         _, err = createConfigNode(s.zk, service.zkConfigPath(), map[string]interface{}{})
         if err != nil {
                 return nil, err
         }
         addService := func(t *topology) error {
                 if _, err := t.ServiceKey(name); err == nil {
                         // No error, so service name already in use.
                         return fmt.Errorf("service name %q is already in use", name)
                 }
@@ skipping 38 matching lines @@
 // Service returns a service state by name.
 func (s *State) Service(name string) (*Service, error) {
         topology, err := readTopology(s.zk)
         if err != nil {
                 return nil, err
         }
         key, err := topology.ServiceKey(name)
         if err != nil {
                 return nil, err
         }
-        return &Service{s.zk, key, name}, nil
+        return &Service{s, key, name}, nil
 }
 
 // AllServices returns all deployed services in the environment.
 func (s *State) AllServices() ([]*Service, error) {
         topology, err := readTopology(s.zk)
         if err != nil {
                 return nil, err
         }
         services := []*Service{}
         for _, key := range topology.ServiceKeys() {
                 name, err := topology.ServiceName(key)
                 if err != nil {
                         return nil, err
                 }
-                services = append(services, &Service{s.zk, key, name})
+                services = append(services, &Service{s, key, name})
         }
         return services, nil
 }
 
 // Unit returns a unit by name.
 func (s *State) Unit(name string) (*Unit, error) {
         serviceName, _, err := parseUnitName(name)
         if err != nil {
                 return nil, err
         }
@@ skipping 32 matching lines @@
         // TODO Create node for bootstrap machine.
 
         // TODO Setup default global settings information.
 
         // Finally creation of /initialized as marker.
         if _, err := s.zk.Create("/initialized", "", 0, zkPermAll); err != nil {
                 return err
         }
         return nil
 }