Added methods for relation endpoints to topology.

state/topology.go

 package state
 
 import (
         "errors"
         "fmt"
         "launchpad.net/goyaml"
         "launchpad.net/gozk/zookeeper"
         "sort"
 )
 
 // The protocol version, which is stored in the /topology node under
 // the "version" key. The protocol version should *only* be updated
 // when we know that a version is in fact actually incompatible.
 const topologyVersion = 1
 
 // NoRelationError represents a relation not found for one or more endpoints.
 type NoRelationError struct {
         Endpoints []RelationEndpoint
 }
 
 // Error returns the string representation of the error.
 func (e NoRelationError) Error() string {
         switch len(e.Endpoints) {
         case 1:
-                return fmt.Sprintf("state: no peer relation for %q", e.Endpoints[0].Id())
+                return fmt.Sprintf("state: no peer relation for %q", e.Endpoints[0])
         case 2:
-                return fmt.Sprintf("state: no relation between %q and %q", e.Endpoints[0].Id(), e.Endpoints[1].Id())
-        }
-        panic("state: illegal relation error")
+                return fmt.Sprintf("state: no relation between %q and %q", e.Endpoints[0], e.Endpoints[1])
+        }
+        panic("state: illegal relation")
 }
 
 // zkTopology is used to marshal and unmarshal the content
 // of the /topology node in ZooKeeper.
 type zkTopology struct {
         Version      int
         Machines     map[string]*zkMachine
         Services     map[string]*zkService
         UnitSequence map[string]int "unit-sequence"
         Relations    map[string]*zkRelation
@@ skipping 16 matching lines @@
 type zkUnit struct {
         Sequence int
         Machine  string
 }
 
 // zkRelation represents the relation data within the·
 // /topology node in ZooKeeper.
 type zkRelation struct {
         Interface string
         Scope     RelationScope
-        Services  map[RelationRole]string
+        Services  map[RelationRole]*zkRelationService
+}
+
+// zkRelationService represents the data of one
+// service of a relation within the /topology
+// node in ZooKeeper.
+type zkRelationService struct {
+        Service      string
+        RelationName string "relation-name"
 }
 
 // check verifies that r is a proper relation.
 func (r *zkRelation) check() error {
         if len(r.Interface) == 0 {
                 return fmt.Errorf("relation interface is empty")
         }
         if len(r.Services) == 0 {
                 return fmt.Errorf("relation has no services")
         }
         counterpart := map[RelationRole]RelationRole{
                 RoleRequirer: RoleProvider,
                 RoleProvider: RoleRequirer,
                 RolePeer:     RolePeer,
         }
-        for serviceRole, serviceKey := range r.Services {
-                if serviceKey == "" {
-                        return fmt.Errorf("relation has %s service with empty key", serviceRole)
+        for serviceRole, service := range r.Services {
+                if service.Service == "" {
+                        return fmt.Errorf("relation has %s service with empty service key", serviceRole)
+                }
+                if service.RelationName == "" {
+                        return fmt.Errorf("relation has %s service with empty relation name", serviceRole)
                 }
                 counterRole, ok := counterpart[serviceRole]
                 if !ok {
                         return fmt.Errorf("relation has unknown service role: %q", serviceRole)
                 }
                 if _, ok := r.Services[counterRole]; !ok {
                         return fmt.Errorf("relation has %s but no %s", serviceRole, counterRole)
                 }
         }
         if len(r.Services) > 2 {
@@ skipping 305 matching lines @@
                 t.topology.Relations = make(map[string]*zkRelation)
         }
         _, ok := t.topology.Relations[relationKey]
         if ok {
                 return fmt.Errorf("relation key %q already in use", relationKey)
         }
         // Check if the relation definition and the service keys are valid.
         if err := relation.check(); err != nil {
                 return err
         }
-        for _, serviceKey := range relation.Services {
-                if err := t.assertService(serviceKey); err != nil {
+        for _, service := range relation.Services {
+                if err := t.assertService(service.Service); err != nil {
                         return err
                 }
         }
-        if relation.Services[RolePeer] == "" {
-                providerKey := relation.Services[RoleProvider]
-                requirerKey := relation.Services[RoleRequirer]
+        if relation.Services[RolePeer] == nil {
+                providerKey := relation.Services[RoleProvider].Service
+                requirerKey := relation.Services[RoleRequirer].Service
                 if providerKey == requirerKey {
-                        return fmt.Errorf("provider and consumer keys must not be the same")
+                        return fmt.Errorf("provider and requirer keys must not be the same")
                 }
         }
         t.topology.Relations[relationKey] = relation
         return nil
 }
 
 // RelationKeys returns the keys for all relations in the topology.
 func (t *topology) RelationKeys() []string {
         keys := []string{}
         for key, _ := range t.topology.Relations {
                 keys = append(keys, key)
         }
         sort.Strings(keys)
         return keys
 }
 
 // RemoveRelation removes the relation with key from the topology.
 func (t *topology) RemoveRelation(key string) {
         delete(t.topology.Relations, key)
 }
 
 // RelationsForService returns all relations that the service
 // with serviceKey is part of.
 func (t *topology) RelationsForService(serviceKey string) (map[string]*zkRelation, error) {
         if err := t.assertService(serviceKey); err != nil {
                 return nil, err
         }
         relations := make(map[string]*zkRelation)
         for relationKey, relation := range t.topology.Relations {
-                for _, roleServiceKey := range relation.Services {
-                        if roleServiceKey == serviceKey {
+                for _, service := range relation.Services {
+                        if service.Service == serviceKey {
                                 relations[relationKey] = relation
                                 break
                         }
                 }
         }
         return relations, nil
 }
 
 // RelationKey returns the key for the relation established between the
 // provided endpoints. If no matching relation is found, error will be
 // of type *NoRelationError.
 func (t *topology) RelationKey(endpoints ...RelationEndpoint) (string, error) {
-        if t.topology.Relations == nil {
-                return "", &NoRelationError{endpoints}
-        }
         switch len(endpoints) {
         case 1:
                 // Just pass.
         case 2:
                 if endpoints[0].Interface != endpoints[1].Interface {
-                        return "", fmt.Errorf("state: differing interfaces %q and %q", endpoints[0].Interface, endpoints[1].Interface)
+                        return "", &NoRelationError{endpoints}
                 }
         default:
-                return "", fmt.Errorf("state: illegal number of endpoints passed")
+                return "", fmt.Errorf("state: illegal number of relation endpoints provided")
         }
         for relationKey, relation := range t.topology.Relations {
                 if relation.Interface != endpoints[0].Interface {
                         continue
                 }
                 found := true
                 for _, endpoint := range endpoints {
-                        serviceKey, ok := relation.Services[endpoint.RelationRole]
-                        if !ok {
-                                found = false
-                                break
-                        }
-                        serviceName, err := t.ServiceName(serviceKey)
-                        if err != nil {
-                                return "", err
-                        }
-                        if serviceName != endpoint.RelationName {
+                        service, ok := relation.Services[endpoint.RelationRole]
+                        if !ok || service.RelationName != endpoint.RelationName {
                                 found = false
                                 break
                         }
                 }
                 if found {
                         // All endpoints tested positive.
                         return relationKey, nil
                 }
         }
         return "", &NoRelationError{endpoints}
@@ skipping 64 matching lines @@
                         }
                 }
                 // Apply the passed function.
                 if err = f(it); err != nil {
                         return "", err
                 }
                 return it.dump()
         }
         return zk.RetryChange(zkTopologyPath, 0, zkPermAll, change)
 }