remove hook package; hooks are not really important at this stage

hook/context.go

+package hook
+
+import (
+        "fmt"
+        "launchpad.net/juju/go/log"
+        "launchpad.net/juju/go/state"
+        "strings"
+)
+
+// Context holds all information necessary to run a hook command.
+type Context struct {
+        state    *state.State
+        local    string
+        relation string
+        members  []string
+}
+
+// NewLocalContext returns a Context tied to a specific unit.
+func NewLocalContext(state *state.State, unitName string) *Context {

[rog, 2012/03/15 15:29:11]

are these constructors worth it?
can't we just export the members of Context - then the caller has the advantage
of being able to use field names in the constructor.

but perhaps you expect more substantial initialisation in the future?

+        return &Context{state, unitName, "", nil}
+}
+
+// NewRelationContext returns a Context tied to a specific unit relation .
+func NewRelationContext(
+        state *state.State, unitName, relationName string, members []string,
+) *Context {
+        return &Context{state, unitName, relationName, members}
+}
+
+// NewBrokenContext returns a Context tied to a specific unit relation (which is
+// known to have been broken).
+func NewBrokenContext(state *state.State, unitName, relationName string) *Context {
+        return &Context{state, unitName, relationName, nil}
+}
+
+// Vars returns an os.Environ-style list of strings that should be set when
+// executing a hook in this Context.
+func (ctx *Context) Vars() []string {

[rog, 2012/03/15 15:29:11]

can't we just put UnitName and Relation as fields into ExecInfo?

+        vars := []string{}
+        if ctx.local != "" {
+                vars = append(vars, "JUJU_UNIT_NAME="+ctx.local)
+        }
+        if ctx.relation != "" {
+                vars = append(vars, "JUJU_RELATION="+ctx.relation)
+        }
+        return vars
+}
+
+// Log is the core of the `log` hook command, and is always meaningful in any
+// Context.
+func (ctx *Context) Log(debug bool, msg string) {
+        s := []string{}
+        if ctx.local != "" {
+                s = append(s, ctx.local)
+        }
+        if ctx.relation != "" {
+                s = append(s, ctx.relation)
+        }
+        full := fmt.Sprintf("Context<%s>: %s", strings.Join(s, ", "), msg)
+        if debug {
+                log.Debugf(full)
+        } else {
+                log.Printf(full)
+        }
+}
+
+// Members is the core of the `relation-list` hook command. It returns a list
+// of unit names (excluding the local unit) participating in this context's
+// relation, and is always meaningful in any Context.
+func (ctx *Context) Members() []string {

[rog, 2012/03/15 15:29:11]

i don't see the need for this method.
for one, a nil slice is an empty slice, so the implementation
would be come just "return ctx.members".

given that, why not just export the field?

+        if ctx.members != nil {
+                return ctx.members
+        }
+        return []string{}
+}