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
 }
 
 // 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 creates a new charm state based on a charm, its URL
-// and its bundle URL.
-func (s *State) AddCharm(ch charm.Charm, curl *charm.URL, url string) (*Charm, error) {
+// 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(),
-                BundleURL: url,
+                BundleURL: bundleURL.String(),
         }
         yaml, err := goyaml.Marshal(data)
         if err != nil {
                 return nil, err
         }
         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), nil
+        return newCharm(s, curl, data)
 }
 
 // Charm returns a charm by the given id.
 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), nil
+        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
         }
@@ skipping 122 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
 }