Merge pull request #8 from ripienaar/7

(#7) Add a provisioned type

Author: ripienaar

README.md

@@ -12,6 +12,7 @@ These lifecycle events are published to the `choria.lifecycle.event.<type>.<comp
 |-----|-----------|
 |Startup|Event to emit when components start, requires `Identity()`, `Component()` and `Version()` options|
 |Shutdown|Event to emit when components shut down, requires `Identity()` and `Component()` options|
+|Provisioned|Event to emit after provisioning of a component, requires `Identity()` and `Component()` options|
 
 #### Sample Events
 ### Schemas
@@ -41,6 +42,17 @@ Event Schemas are stored in the [Choria Schemas repository](https://github.com/c
 }
 ```
 
+#### Provisioned
+
+```json
+{
+    "protocol":"choria:lifecycle:provisioned:1",
+    "identity":"c1.example.net",
+    "component":"server",
+    "timestamp":1535369536
+}
+```
+
 ## Viewing events
 
 In a shell configured as a Choria Client run `choria tool event` to view events in real time.
@@ -59,7 +71,7 @@ err = lifecycle.PublishEvent(event, conn)
 
 If you are emitting `lifecycle.Shutdown` events right before exiting be sure to call `conn.Close()` so the buffers are flushed prior to shutdown.
 
-## Receiving a events
+## Receiving events
 
 These events are used to orchestrate associated tools like the [Provisioning Server](https://github.com/choria-io/provisioning-agent) that listens for these events and immediately add a new node to the provisioning queue.
 

basic.go

@@ -0,0 +1,52 @@
+package lifecycle
+
+import "fmt"
+
+type basicEvent struct {
+	Protocol  string `json:"protocol"`
+	Ident     string `json:"identity"`
+	Comp      string `json:"component"`
+	Timestamp int64  `json:"timestamp"`
+
+	etype string
+	dtype Type
+}
+
+// Component is the component that produced the event
+func (e *basicEvent) Component() string {
+	return e.Comp
+}
+
+// SetComponent sets the component for the event
+func (e *basicEvent) SetComponent(c string) {
+	e.Comp = c
+}
+
+// SetIdentity sets the identity for the event
+func (e *basicEvent) SetIdentity(i string) {
+	e.Ident = i
+}
+
+// Identity sets the identity for the event
+func (e *basicEvent) Identity() string {
+	return e.Ident
+}
+
+// Target is where to publish the event to
+func (e *basicEvent) Target() (string, error) {
+	if e.Comp == "" {
+		return "", fmt.Errorf("event is not complete, component has not been set")
+	}
+
+	return fmt.Sprintf("choria.lifecycle.event.%s.%s", e.etype, e.Comp), nil
+}
+
+// String is text suitable to display on the console etc
+func (e *basicEvent) String() string {
+	return fmt.Sprintf("[%s] %s: %s", e.etype, e.Ident, e.Component())
+}
+
+// Type is the type of event
+func (e *basicEvent) Type() Type {
+	return e.dtype
+}

basic_test.go

@@ -0,0 +1,60 @@
+package lifecycle
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("basicEvent", func() {
+	Describe("Component", func() {
+		It("Should return the right component", func() {
+			e := &basicEvent{Comp: "test"}
+			Expect(e.Component()).To(Equal("test"))
+		})
+	})
+
+	Describe("SetComponent", func() {
+		It("Should set the component", func() {
+			e := &basicEvent{}
+			e.SetComponent("component")
+			Expect(e.Comp).To(Equal("component"))
+		})
+	})
+
+	Describe("SetIdentity", func() {
+		It("Should set the identity", func() {
+			e := &basicEvent{}
+			e.SetIdentity("node.example")
+			Expect(e.Ident).To(Equal("node.example"))
+		})
+	})
+
+	Describe("Target", func() {
+		It("Should detect incomplete events", func() {
+			e := &basicEvent{etype: "basic"}
+			_, err := e.Target()
+			Expect(err).To(MatchError("event is not complete, component has not been set"))
+		})
+
+		It("Should return the right target", func() {
+			e := &basicEvent{etype: "basic", Comp: "ginkgo"}
+			t, err := e.Target()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(t).To(Equal("choria.lifecycle.event.basic.ginkgo"))
+		})
+	})
+
+	Describe("String", func() {
+		It("Should return the right string", func() {
+			e := &basicEvent{etype: "basic", Comp: "ginkgo", Ident: "node.example"}
+			Expect(e.String()).To(Equal("[basic] node.example: ginkgo"))
+		})
+	})
+
+	Describe("Type", func() {
+		It("Should return the right Type", func() {
+			e := &basicEvent{etype: "basic", dtype: Shutdown, Comp: "ginkg", Ident: "node.example"}
+			Expect(e.Type()).To(Equal(Shutdown))
+		})
+	})
+})

lifecycle.go

@@ -21,11 +21,14 @@ type Type int
 const (
 	_ = iota
 
-	// Startup is an event components should publish when they start
+	// Startup is an event components can publish when they start
 	Startup Type = iota
 
-	// Shutdown is an event components should publish when they shutdown
+	// Shutdown is an event components can publish when they shutdown
 	Shutdown
+
+	// Provisioned is an event components can publish post provisioning
+	Provisioned
 )
 
 var eventTypes = make(map[string]Type)

lifecycle_test.go

@@ -4,7 +4,6 @@ import (
 	"os"
 	"testing"
 
-	"github.com/choria-io/go-choria/config"
 	gomock "github.com/golang/mock/gomock"
 
 	. "github.com/onsi/ginkgo"
@@ -21,16 +20,11 @@ var _ = Describe("Events", func() {
 	var (
 		mockctl *gomock.Controller
 		conn    *MockPublishConnector
-		cfg     *config.Config
-		err     error
 	)
 
 	BeforeEach(func() {
 		mockctl = gomock.NewController(GinkgoT())
 		conn = NewMockPublishConnector(mockctl)
-		cfg, err = config.NewDefaultConfig()
-		Expect(err).ToNot(HaveOccurred())
-		cfg.Identity = "test.ginkgo"
 		mockTime = 1535106973
 	})
 
@@ -49,7 +43,7 @@ var _ = Describe("Events", func() {
 
 	Describe("EventTypeNames", func() {
 		It("Should list all known types", func() {
-			Expect(EventTypeNames()).To(Equal([]string{"shutdown", "startup"}))
+			Expect(EventTypeNames()).To(Equal([]string{"provisioned", "shutdown", "startup"}))
 		})
 	})
 
@@ -72,10 +66,11 @@ var _ = Describe("Events", func() {
 
 	Describe("PublishEvent", func() {
 		It("Should publish the event to the right destination", func() {
-			event, err := New(Startup, Component("ginkgo"))
+			event, err := New(Startup, Component("ginkgo"), Version("1.2.3"), Identity("ginkgo.example.net"))
 			Expect(err).ToNot(HaveOccurred())
 			mockTime = 1535106973
-			conn.EXPECT().PublishRaw("choria.lifecycle.event.startup.ginkgo", []byte(`{"protocol":"choria:lifecycle:startup:1","identity":"","version":"","timestamp":1535106973,"component":"ginkgo"}`))
+			Expect(err).ToNot(HaveOccurred())
+			conn.EXPECT().PublishRaw("choria.lifecycle.event.startup.ginkgo", []byte(`{"protocol":"choria:lifecycle:startup:1","identity":"ginkgo.example.net","component":"ginkgo","timestamp":1535106973,"version":"1.2.3"}`))
 			PublishEvent(event, conn)
 		})
 	})

provisioned.go

@@ -0,0 +1,60 @@
+package lifecycle
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// ProvisionedEvent is a choria::lifecycle::provisioned:1 event
+type ProvisionedEvent struct {
+	basicEvent
+}
+
+func init() {
+	eventTypes["provisioned"] = Provisioned
+
+	eventJSONParsers[Provisioned] = func(j []byte) (Event, error) {
+		return newProvisionedEventFromJSON(j)
+	}
+
+	eventFactories[Provisioned] = func(opts ...Option) Event {
+		return newProvisionedEvent(opts...)
+	}
+}
+
+func newProvisionedEvent(opts ...Option) *ProvisionedEvent {
+	event := &ProvisionedEvent{
+		basicEvent: basicEvent{
+			Protocol:  "choria:lifecycle:provisioned:1",
+			Timestamp: timeStamp(),
+			etype:     "provisioned",
+			dtype:     Provisioned,
+		},
+	}
+
+	for _, o := range opts {
+		o(event)
+	}
+
+	return event
+}
+
+func newProvisionedEventFromJSON(j []byte) (*ProvisionedEvent, error) {
+	event := &ProvisionedEvent{
+		basicEvent: basicEvent{
+			etype: "provisioned",
+			dtype: Provisioned,
+		},
+	}
+
+	err := json.Unmarshal(j, event)
+	if err != nil {
+		return nil, err
+	}
+
+	if event.Protocol != "choria:lifecycle:provisioned:1" {
+		return nil, fmt.Errorf("invalid protocol '%s'", event.Protocol)
+	}
+
+	return event, nil
+}

provisioned_test.go

@@ -0,0 +1,32 @@
+package lifecycle
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ProvisionedEvent", func() {
+	Describe("newProvisionedEvent", func() {
+		It("Should create the event and set options", func() {
+			event := newProvisionedEvent(Component("ginkgo"))
+			Expect(event.Component()).To(Equal("ginkgo"))
+			Expect(event.dtype).To(Equal(Provisioned))
+			Expect(event.etype).To(Equal("provisioned"))
+		})
+	})
+
+	Describe("newProvisionedEventFromJSON", func() {
+		It("Should detect invalid protocols", func() {
+			_, err := newProvisionedEventFromJSON([]byte(`{"protocol":"x"}`))
+			Expect(err).To(MatchError("invalid protocol 'x'"))
+		})
+
+		It("Should parse valid events", func() {
+			event, err := newProvisionedEventFromJSON([]byte(`{"protocol":"choria:lifecycle:provisioned:1", "component":"ginkgo"}`))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(event.Component()).To(Equal("ginkgo"))
+			Expect(event.dtype).To(Equal(Provisioned))
+			Expect(event.etype).To(Equal("provisioned"))
+		})
+	})
+})

shutdown.go

@@ -7,10 +7,7 @@ import (
 
 // ShutdownEvent is a choria:lifecycle:shutdown:1 event
 type ShutdownEvent struct {
-	Protocol  string `json:"protocol"`
-	Ident     string `json:"identity"`
-	Comp      string `json:"component"`
-	Timestamp int64  `json:"timestamp"`
+	basicEvent
 }
 
 func init() {
@@ -27,8 +24,12 @@ func init() {
 
 func newShutdownEvent(opts ...Option) *ShutdownEvent {
 	event := &ShutdownEvent{
-		Protocol:  "choria:lifecycle:shutdown:1",
-		Timestamp: timeStamp(),
+		basicEvent: basicEvent{
+			Protocol:  "choria:lifecycle:shutdown:1",
+			Timestamp: timeStamp(),
+			etype:     "shutdown",
+			dtype:     Shutdown,
+		},
 	}
 
 	for _, o := range opts {
@@ -39,7 +40,12 @@ func newShutdownEvent(opts ...Option) *ShutdownEvent {
 }
 
 func newShutdownEventFromJSON(j []byte) (*ShutdownEvent, error) {
-	event := &ShutdownEvent{}
+	event := &ShutdownEvent{
+		basicEvent: basicEvent{
+			etype: "shutdown",
+			dtype: Shutdown,
+		},
+	}
 	err := json.Unmarshal(j, event)
 	if err != nil {
 		return nil, err
@@ -51,42 +57,3 @@ func newShutdownEventFromJSON(j []byte) (*ShutdownEvent, error) {
 
 	return event, nil
 }
-
-// Component is the component that produced the event
-func (e *ShutdownEvent) Component() string {
-	return e.Comp
-}
-
-// SetComponent sets the component for the event
-func (e *ShutdownEvent) SetComponent(c string) {
-	e.Comp = c
-}
-
-// SetIdentity sets the identity for the event
-func (e *ShutdownEvent) SetIdentity(i string) {
-	e.Ident = i
-}
-
-// Identity sets the identity for the event
-func (e *ShutdownEvent) Identity() string {
-	return e.Ident
-}
-
-// Target is where to publish the event to
-func (e *ShutdownEvent) Target() (string, error) {
-	if e.Comp == "" {
-		return "", fmt.Errorf("event is not complete, component has not been set")
-	}
-
-	return fmt.Sprintf("choria.lifecycle.event.shutdown.%s", e.Comp), nil
-}
-
-// String is text suitable to display on the console etc
-func (e *ShutdownEvent) String() string {
-	return fmt.Sprintf("[shutdown] %s: %s", e.Ident, e.Component())
-}
-
-// Type is the type of event
-func (e *ShutdownEvent) Type() Type {
-	return Shutdown
-}