implement relation-set

cmd/jujuc/server/relation-set.go

+package server
+
+import (
+        "fmt"
+        "launchpad.net/gnuflag"
+        "launchpad.net/goyaml"
+        "launchpad.net/juju-core/cmd"
+        "strconv"
+        "strings"
+)
+
+// RelationSetCommand implements the relation-set command.
+type RelationSetCommand struct {
+        *HookContext
+        RelationId int
+        Settings   map[string]interface{}
+}
+
+func NewRelationSetCommand(ctx *HookContext) (cmd.Command, error) {
+        return &RelationSetCommand{HookContext: ctx, Settings: map[string]interface{}{}}, nil
+}
+
+func (c *RelationSetCommand) Info() *cmd.Info {
+        return &cmd.Info{
+                "relation-set", "<key=value> [, ...]", "set relation settings", "",
+        }
+}
+
+func (c *RelationSetCommand) Init(f *gnuflag.FlagSet, args []string) error {
+        _, defaultId := c.relationIdentifiers()
+        relationId := ""
+        f.StringVar(&relationId, "r", defaultId, "relation id")
+        if err := f.Parse(true, args); err != nil {
+                return err
+        }
+        if relationId == "" {
+                if c.HookContext.RelationId == -1 {
+                        return fmt.Errorf("no relation specified")

[rog, 2012/07/31 08:28:08]

"running in a non-relation hook" or something similar?
after all, the user isn't specifying the relation - it's already specified (or
not, for non-relation hooks).

[fwereade, 2012/07/31 23:00:11]

I don't think so -- the user might be specifying the relation, whatever sort of
context we're in. This indicates that -r was not set, and it needs to be.

+                }
+                c.RelationId = c.HookContext.RelationId
+        } else {
+                trim := relationId
+                if idx := strings.LastIndex(trim, ":"); idx != -1 {
+                        trim = trim[idx+1:]
+                }
+                id, err := strconv.Atoi(trim)
+                if err != nil {
+                        return fmt.Errorf("invalid relation id %q", relationId)
+                }
+                if _, found := c.Relations[id]; !found {
+                        return fmt.Errorf("unknown relation id %q", relationId)
+                }
+                c.RelationId = id
+        }
+        args = f.Args()
+        if len(args) == 0 {
+                return fmt.Errorf("no settings specified")
+        }
+        for _, kv := range args {
+                parts := strings.SplitN(kv, "=", 2)
+                var err error
+                var value interface{}
+                if parts[0] == "" {
+                        err = fmt.Errorf("no key specified")
+                } else {
+                        err = goyaml.Unmarshal([]byte(parts[1]), &value)

[rog, 2012/07/31 08:28:08]

this surprises me. 
does this mean it's an error to do a relation-set of anything that doesn't parse
as YAML?

for instance: relation-set "message=can't do something"
would give an error.

what are we gaining by not just setting a simple string value?

[fwereade, 2012/07/31 23:00:11]

The glorious taste of sweet sweet crack, it emerges. Nice catch.

[rog, 2012/08/03 13:49:42]

that made me smile.

+                }
+                if err != nil {
+                        return fmt.Errorf("cannot parse %q: %v", kv, err)
+                }
+                c.Settings[parts[0]] = value
+        }
+        return nil
+}
+
+func (c *RelationSetCommand) Run(ctx *cmd.Context) (err error) {
+        node, err := c.Relations[c.RelationId].Settings()
+        for k, v := range c.Settings {
+                if v != nil {
+                        node.Set(k, v)
+                } else {
+                        node.Delete(k)
+                }
+        }
+        return nil
+}