[WIP] Visualisation Backend

docs/export_api_v0.1.0.md

@@ -0,0 +1,82 @@
+Export API
+==========
+
+This document defined the API used for exporting data from Raft
+
+## Enabling Exporting ##
+By default the exporting function is off, to turn it on `pfsd` must be run with
+`-enable-export` flag.
+
+The default port for the exporter is `10100`, and it can be changed with
+`-export-port <port>`
+
+## API Specification ##
+| Name | Description | Available Options |
+| ---- | ----------- | --------------- |
+| type | Defines the type of the message | `state`<br> `nodechange`<br>`event`
+| data | The data changes depending on what type the message is | [See Below](#Data)
+
+The first message send is of type `state`, it is send on connecting to the server
+
+### Data ###
+| Type | Content |
+| ---- | ------- |
+| `state` | `nodes` - Array of [nodes](#Node) |
+| `nodechange` | `action` - Can be of type `add`, `delete`, `update`<br>`node` - Single [node](#Node) to which the change applies. |
+| `event` | `source` - Node UUID which is the source of the event<br>`target` - Node UUID which is the target of the event<br>`details` - Specific details of the event, declared internally
+
+### Node ###
+| Field Name | Description |
+| ---------- | ----------- |
+| `uuid` | Unique identifier for the node |
+| `commonName` | Display Name of the node |
+| `addr` | Address of the node, in a `host:port` format
+| `state` | State of the node, can contain multiple states, with <code>&#124;</code> as the delimiter. It's the server's responsibility to make sure there are no race conditions in states. The available states are as follows: `current`, `leader`, `candidate`, `follower` (or blank), `inactive`
+
+## Examples ##
+```json
+{
+  "type":"state",
+  "data": {
+    "nodes": [
+      {
+        "uuid":"1234-abcd-5678-efgh",
+        "commonName":"node-1",
+        "addr":"10.0.0.1:67890",
+        "state":"current|leader"
+      }, {
+        "uuid":"9012-ijkl-3456-mnop",
+        "commonName":"node-2",
+        "addr":"10.0.0.2:78901",
+        "state":"inactive"
+      }
+    ]
+  }
+}
+```
+
+```json
+{
+  "type":"nodechange",
+  "data": {
+    "action":"update",
+    "node":{
+      "uuid":"9012-ijkl-3456-mnop",
+      "commonName":"node-2",
+      "addr":"10.0.0.2:78901",
+      "state":"follower"
+    }
+  }
+}
+```
+
+```json
+{
+  "type":"event",
+  "data": {
+    "source":"9012-ijkl-3456-mnop",
+    "target":"1234-abcd-5678-efgh",
+    "details": "write-request"
+  }
+}
+```

paranoid-cli/commands/mountcmd.go

@@ -163,6 +163,10 @@ func doMount(c *cli.Context, args []string) {
 			if iface != "" {
 				pfsdFlags = append(pfsdFlags, "-interface="+iface)
 			}
+			if c.Bool("enable-export") {
+				pfsdFlags = append(pfsdFlags, "-enable-export")
+				pfsdFlags = append(pfsdFlags, "-export-port="+c.String("export-port"))
+			}
 			cmd := exec.Command("pfsd", append(pfsdFlags, pfsdArgs...)...)
 			err = cmd.Start()
 			if err != nil {

paranoid-cli/main.go

@@ -12,7 +12,37 @@ import (
 	"path"
 )
 
+
 func main() {
+	// store the flags contained by both mount and automount
+	mountFlags  := []cli.Flag{
+		cli.BoolFlag{
+			Name:  "n, noprompt",
+			Usage: "disable the prompt when attempting to mount a PFS without TLS/SSL",
+		},
+		cli.StringFlag{
+			Name:  "i, interface",
+			Usage: "name a network interface over which to make connections. Defaults to default interface",
+		},
+		cli.StringFlag{
+			Name:  "d, discovery-addr",
+			Usage: "use a custom discovery server. Specified with ip:port. Defaults to public discovery server",
+		},
+		cli.StringFlag{
+			Name:  "pool-password",
+			Usage: "connect to a pool that is password protected",
+		},
+		cli.BoolFlag{
+			Name: "enable-export",
+			Usage: "enable exporting of Raft",
+		},
+		cli.StringFlag{
+			Name: "export-port",
+			Value: "10100",
+			Usage: "port on which the Raft exporter should listen",
+		},
+	}
+
 
 	usr, err := user.Current()
 	if err != nil {
@@ -46,7 +76,7 @@ func main() {
 	app := cli.NewApp()
 	app.Name = "paranoid-cli"
 	app.HelpName = "paranoid-cli"
-	app.Version = "0.4.1"
+	app.Version = "0.4.2"
 	app.Flags = []cli.Flag{
 		cli.BoolFlag{
 			Name:  "verbose",
@@ -91,24 +121,7 @@ func main() {
 			Usage:     "mount a paranoid file system",
 			ArgsUsage: "pfs-name mountpoint",
 			Action:    commands.Mount,
-			Flags: []cli.Flag{
-				cli.BoolFlag{
-					Name:  "n, noprompt",
-					Usage: "disable the prompt when attempting to mount a PFS without TLS/SSL",
-				},
-				cli.StringFlag{
-					Name:  "i, interface",
-					Usage: "name a network interface over which to make connections. Defaults to default interface",
-				},
-				cli.StringFlag{
-					Name:  "d, discovery-addr",
-					Usage: "Use a custom discovery server. Specified with ip:port. Defaults to public discovery server",
-				},
-				cli.StringFlag{
-					Name:  "pool-password",
-					Usage: "connect to a pool that is password portected",
-				},
-			},
+			Flags:     mountFlags,
 		},
 		{
 			Name:      "secure",
@@ -153,24 +166,7 @@ func main() {
 			Usage:     "automount a paranoid file system with previous settings",
 			ArgsUsage: "pfs-name",
 			Action:    commands.AutoMount,
-			Flags: []cli.Flag{
-				cli.BoolFlag{
-					Name:  "n, noprompt",
-					Usage: "disable the prompt when attempting to mount a PFS without TLS/SSL",
-				},
-				cli.StringFlag{
-					Name:  "i, interface",
-					Usage: "name a network interface over which to make connections. Defaults to default interface",
-				},
-				cli.StringFlag{
-					Name:  "d, discovery-addr",
-					Usage: "Use a custom discovery server. Specified with ip:port. Defaults to public discovery server",
-				},
-				cli.StringFlag{
-					Name:  "pool-password",
-					Usage: "connect to a pool that is password portected",
-				},
-			},
+			Flags: 		 mountFlags,
 		},
 		{
 			Name:      "unmount",

pfsd/exporter/client.go

@@ -0,0 +1,23 @@
+package exporter
+
+import (
+	"golang.org/x/net/websocket"
+)
+
+type client struct {
+	ws   *websocket.Conn
+	msgs chan Message
+}
+
+func (c *client) write(msg Message) {
+	c.msgs <- msg
+}
+
+func (c *client) listen() {
+	for {
+		select {
+		case msg := <-c.msgs:
+			websocket.JSON.Send(c.ws, msg)
+		}
+	}
+}

pfsd/exporter/exporter.go

@@ -0,0 +1,72 @@
+// exporter package creates an WebServer which exports Raft information
+package exporter
+
+import (
+	"github.com/cpssd/paranoid/logger"
+	"github.com/cpssd/paranoid/pfsd/globals"
+)
+
+var (
+	Log      *logger.ParanoidLogger
+	server   *Server
+	nodeList map[string]MessageNode
+)
+
+func init() {
+	nodeList = make(map[string]MessageNode)
+}
+
+func Send(msg Message) {
+	server.Send(msg)
+}
+
+func NewStdServer(port string) {
+	server = NewServer(port)
+}
+
+func Listen() {
+	globals.Wait.Done()
+	server.Run()
+}
+
+// SetState is used to set the local exporter state
+func SetState(nodes []MessageNode) {
+	for i := 0; i < len(nodes); i++ {
+		nodeList[nodes[i].Uuid] = nodes[i]
+	}
+}
+
+// NodeChange sends a message to the client whenever there is a change in nodes
+func NodeChange(node MessageNode) {
+	msg := Message{
+		Type: NodeChangeMessage,
+		Data: MessageData{
+			Node: node,
+		},
+	}
+
+	// Check does the message exist to determine the response
+	// TODO: 	Add implementation when a node is deleted. This is currently
+	// 				not supported with our raft implementation
+	if _, ok := nodeList[node.Uuid]; !ok {
+		msg.Data.Action = "add"
+	} else {
+		msg.Data.Action = "update"
+	}
+
+	nodeList[node.Uuid] = node
+	server.Send(msg)
+}
+
+// Send an event that happened to the client
+func Event(msg Message) {
+	server.Send(msg)
+}
+
+func toNodeArray(m map[string]MessageNode) []MessageNode {
+	var nodes []MessageNode
+	for _, n := range m {
+		nodes = append(nodes, n)
+	}
+	return nodes
+}

pfsd/exporter/exporter_test.go

@@ -0,0 +1 @@
+package exporter

pfsd/exporter/message.go

@@ -0,0 +1,51 @@
+package exporter
+
+type MessageType string
+
+const (
+	StateMessage      MessageType = "state"
+	NodeChangeMessage             = "nodechange"
+	RaftEventMessage              = "event"
+)
+
+func (m MessageType) String() string {
+	switch m {
+	case StateMessage:
+		return "state"
+	case NodeChangeMessage:
+		return "nodechange"
+	case RaftEventMessage:
+		return "event"
+	default:
+		return ""
+	}
+}
+
+type Message struct {
+	Type MessageType `json:"type"`
+	Data MessageData `json:"data"`
+}
+
+type MessageData struct {
+	// Used for "status"
+	Nodes []MessageNode `json:"nodes,omitempty"`
+	// Used for "nodechange"
+	Action string `json:"action,omitempty"`
+	// Used for "nodechange"
+	Node MessageNode `json:"node,omitempty"`
+	// Used for "event"
+	Event MessageEvent `json:"event,omitempty"`
+}
+
+type MessageNode struct {
+	Uuid       string `json:"uuid"`
+	CommonName string `json:"commonName"`
+	State      string `json:"state"`
+	Addr       string `json:"addr"`
+}
+
+type MessageEvent struct {
+	Source  string `json:"source"`
+	Target  string `json:"target"`
+	Details string `json:"details"`
+}

pfsd/exporter/server.go

@@ -0,0 +1,44 @@
+package exporter
+
+import (
+	"golang.org/x/net/websocket"
+	"net/http"
+)
+
+type Server struct {
+	messages chan Message
+	port     string
+	client   *client
+}
+
+func NewServer(port string) *Server {
+	return &Server{
+		port:     port,
+		messages: make(chan Message),
+	}
+}
+
+// Run starts the websocket server
+func (s *Server) Run() {
+	onConnected := func(ws *websocket.Conn) {
+		s.client = &client{
+			ws:   ws,
+			msgs: make(chan Message),
+		}
+		s.client.listen()
+
+		// Send the state message
+		s.Send(Message{
+			Type: StateMessage,
+			Data: MessageData{
+				Nodes: toNodeArray(nodeList),
+			},
+		})
+	}
+
+	http.ListenAndServe(":"+s.port, websocket.Handler(onConnected))
+}
+
+func (s *Server) Send(msg Message) {
+	s.client.write(msg)
+}