Implements "juju actions <service>".

charm/bundle.go

 // Copyright 2011, 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package charm
 
 import (
         "archive/zip"
         "errors"
         "fmt"
         "io"
         "io/ioutil"
         "os"
         "path/filepath"
         "strconv"
 
         "launchpad.net/juju-core/utils/set"
         ziputil "launchpad.net/juju-core/utils/zip"
 )
 
 // The Bundle type encapsulates access to data and operations
 // on a charm bundle.
 type Bundle struct {
-        Path     string // May be empty if Bundle wasn't read from a file
-        meta     *Meta
-        config   *Config
-        revision int
-        r        io.ReaderAt
-        size     int64
+        Path        string // May be empty if Bundle wasn't read from a file
+        meta        *Meta
+        config      *Config
+        actionsSpec *ActionsSpec
+        revision    int
+        r           io.ReaderAt
+        size        int64
 }
 
 // Trick to ensure *Bundle implements the Charm interface.
 var _ Charm = (*Bundle)(nil)
 
 // ReadBundle returns a Bundle for the charm in path.
 func ReadBundle(path string) (bundle *Bundle, err error) {
         f, err := os.Open(path)
         if err != nil {
                 return
@@ skipping 39 matching lines @@
         } else if err != nil {
                 return nil, err
         } else {
                 b.config, err = ReadConfig(reader)
                 reader.Close()
                 if err != nil {
                         return nil, err
                 }
         }
 
+        reader, err = zipOpen(zipr, "actions.yaml")
+        if _, ok := err.(*noBundleFile); ok {
+                b.actionsSpec = NewActionsSpec()
+        } else if err != nil {
+                return nil, err
+        } else {
+                b.actionsSpec, err = ReadActionsSpec(reader)
+                reader.Close()
+                if err != nil {
+                        return nil, err
+                }
+        }
+
         reader, err = zipOpen(zipr, "revision")
         if err != nil {
                 if _, ok := err.(*noBundleFile); !ok {
                         return
                 }
                 b.revision = b.meta.OldRevision
         } else {
                 _, err = fmt.Fscan(reader, &b.revision)
                 if err != nil {
                         return nil, errors.New("invalid revision file")
@@ skipping 37 matching lines @@
 func (b *Bundle) Meta() *Meta {
         return b.meta
 }
 
 // Config returns the Config representing the config.yaml file
 // for the charm bundle.
 func (b *Bundle) Config() *Config {
         return b.config
 }
 
+// Actions returns the ActionSpec representing the actions.yaml file
+// for the charm bundle.
+func (b *Bundle) ActionsSpec() *ActionsSpec {
+        return b.actionsSpec
+}
+
 type zipReadCloser struct {
         io.Closer
         *zip.Reader
 }
 
 // zipOpen returns a zipReadCloser.
 func (b *Bundle) zipOpen() (*zipReadCloser, error) {
         // If we don't have a Path, try to use the original ReaderAt.
         if b.Path == "" {
                 r, err := zip.NewReader(b.r, b.size)
@@ skipping 84 matching lines @@
                 return nil
         }
 }
 
 // FWIW, being able to do this is awesome.
 type readAtBytes []byte
 
 func (b readAtBytes) ReadAt(out []byte, off int64) (n int, err error) {
         return copy(out, b[off:]), nil
 }