Refactor server

 - move handlers into separate files
 - use interfaces for handlers, etc
 - update README.md files

Author: thani-sh

README.md

@@ -1,23 +1,3 @@
 # Go DDP
 
 DDP server and client implemented with go.
-
-## Server Example
-
-```go
-package main
-
-import (
-  "github.com/meteorhacks/goddp"
-)
-
-func main() {
-  server := goddp.NewServer()
-  server.Method("hello", methodHandler)
-  server.Listen(":1337")
-}
-
-func methodHandler(p []interface{}) (interface{}, error) {
-  return "result", nil
-}
-```

goddp.go

@@ -12,12 +12,20 @@ import (
 )
 
 func main() {
-  server := server.New()
-  server.Method("hello", methodHandler)
-  server.Listen(":1337")
+  s := server.New()
+  s.Method("double", handler)
+  s.Listen(":1337")
 }
 
-func methodHandler(p []interface{}) (interface{}, error) {
-  return "result", nil
+func handler(ctx server.MethodContext) {
+  n, ok := ctx.Args[0].(float64)
+
+  if !ok {
+    ctx.SendError("invalid parameters")
+  } else {
+    ctx.SendResult(n * 2)
+  }
+
+  ctx.SendUpdated()
 }
 ```

server/README.md

@@ -0,0 +1,20 @@
+package server
+
+import (
+	"github.com/meteorhacks/goddp/utils/random"
+)
+
+type ConnectHandler struct {
+	server Server
+}
+
+func NewConnectHandler(s Server) Handler {
+	return &ConnectHandler{s}
+}
+
+func (h *ConnectHandler) handle(res Response, m Message) error {
+	return res.WriteJSON(map[string]string{
+		"msg":     "connected",
+		"session": random.Id(17),
+	})
+}

server/handler_connect.go

@@ -0,0 +1,28 @@
+package server
+
+import (
+	"errors"
+	"fmt"
+)
+
+type MethodHandler struct {
+	server Server
+}
+
+func NewMethodHandler(s Server) Handler {
+	return &MethodHandler{s}
+}
+
+func (h *MethodHandler) handle(res Response, m Message) error {
+	fn, ok := h.server.methods[m.Method]
+
+	if !ok {
+		err := errors.New(fmt.Sprintf("method %s not found", m.Method))
+		return err
+	}
+
+	ctx := NewMethodContext(m, res)
+	fn(ctx)
+
+	return nil
+}

server/handler_method.go

@@ -0,0 +1,30 @@
+package server
+
+type PingHandler struct {
+	server Server
+}
+
+func NewPingHandler(s Server) Handler {
+	return &PingHandler{s}
+}
+
+func (h *PingHandler) handle(res Response, m Message) error {
+	if m.ID != "" {
+		return h.withId(res, m)
+	} else {
+		return h.withoutId(res, m)
+	}
+}
+
+func (p *PingHandler) withId(res Response, m Message) error {
+	return res.WriteJSON(map[string]string{
+		"msg": "pong",
+		"id":  m.ID,
+	})
+}
+
+func (p *PingHandler) withoutId(res Response, m Message) error {
+	return res.WriteJSON(map[string]string{
+		"msg": "pong",
+	})
+}

server/handler_ping.go

@@ -0,0 +1,64 @@
+package server
+
+import (
+	"errors"
+)
+
+type MethodContext struct {
+	ID      string
+	Args    []interface{}
+	Res     Response
+	Done    bool
+	Updated bool
+}
+
+func NewMethodContext(m Message, res Response) MethodContext {
+	ctx := MethodContext{}
+	ctx.ID = m.ID
+	ctx.Args = m.Params
+	ctx.Res = res
+	return ctx
+}
+
+func (ctx *MethodContext) SendResult(r interface{}) error {
+	if ctx.Done {
+		err := errors.New("already sent results for method")
+		return err
+	}
+
+	ctx.Done = true
+	return ctx.Res.WriteJSON(map[string]interface{}{
+		"msg":    "result",
+		"id":     ctx.ID,
+		"result": r,
+	})
+}
+
+func (ctx *MethodContext) SendError(e string) error {
+	if ctx.Done {
+		err := errors.New("already sent results for method")
+		return err
+	}
+
+	ctx.Done = true
+	return ctx.Res.WriteJSON(map[string]interface{}{
+		"msg": "result",
+		"id":  ctx.ID,
+		"error": map[string]string{
+			"error": e,
+		},
+	})
+}
+
+func (ctx *MethodContext) SendUpdated() error {
+	if ctx.Updated {
+		err := errors.New("already sent updated for method")
+		return err
+	}
+
+	ctx.Updated = true
+	return ctx.Res.WriteJSON(map[string]interface{}{
+		"msg":     "updated",
+		"methods": []string{ctx.ID},
+	})
+}

server/method_context.go

@@ -3,138 +3,84 @@ package server
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"net/http"
 
 	"github.com/gorilla/websocket"
-	"github.com/meteorhacks/goddp/utils/random"
 )
 
 type Server struct {
-	methods  map[string]MethodHandler
+	handlers map[string]Handler
+	methods  map[string]MethodFn
 	upgrader websocket.Upgrader
 }
 
 func New() Server {
-	server := Server{}
-	server.methods = make(map[string]MethodHandler)
-	server.upgrader = websocket.Upgrader{
+	s := Server{}
+	s.methods = make(map[string]MethodFn)
+	s.upgrader = websocket.Upgrader{
 		ReadBufferSize:  1024,
 		WriteBufferSize: 1024,
 	}
 
-	return server
-}
+	s.handlers = map[string]Handler{
+		"connect": NewConnectHandler(s),
+		"ping":    NewPingHandler(s),
+		"method":  NewMethodHandler(s),
+	}
 
-func (s *Server) Method(n string, h MethodHandler) {
-	s.methods[n] = h
+	return s
 }
 
-func (s *Server) Listen(ipPort string) {
+func (s *Server) Listen(addr string) {
 	http.HandleFunc("/websocket", s.Handler)
-	http.ListenAndServe(ipPort, nil)
+	http.ListenAndServe(addr, nil)
+}
+
+func (s *Server) Method(name string, fn MethodFn) {
+	s.methods[name] = fn
 }
 
 func (s *Server) Handler(w http.ResponseWriter, r *http.Request) {
 	ws, err := s.upgrader.Upgrade(w, r, nil)
-
 	if err != nil {
-		fmt.Println("Error: could not creating websocket connection")
+		// TODO => handle non-websocket requests
 		return
 	}
 
 	for {
-		msg, err := readMessage(ws)
+		msg, err := readMessage(req)
 
 		if err != nil {
-			ws.Close()
 			break
 		}
 
-		switch {
-		case msg.Msg == "ping":
-			go s.handlePing(ws, msg)
-		case msg.Msg == "connect":
-			go s.handleConnect(ws, msg)
-		case msg.Msg == "method":
-			go s.handleMethod(ws, msg)
-		default:
-			fmt.Println("Error: unknown ddp message", *msg)
-			ws.Close()
+		if h, ok := s.handlers[msg.Msg]; ok {
+			go h.handle(res, msg)
+		} else {
+			// TODO => send "error" ddp message
 			break
 		}
 	}
-}
-
-func (s *Server) handleConnect(c *websocket.Conn, m *Message) {
-	err := c.WriteJSON(map[string]string{
-		"msg":     "connected",
-		"session": random.Id(17),
-	})
 
-	if err != nil {
-		fmt.Println(err)
-	}
+	ws.Close()
 }
 
-func (s *Server) handlePing(c *websocket.Conn, m *Message) {
-	if m.Id != "" {
-		err := c.WriteJSON(map[string]string{
-			"msg": "pong",
-			"id":  m.Id,
-		})
-
-		if err != nil {
-			fmt.Println(err)
-		}
-	} else {
-		err := c.WriteJSON(map[string]string{
-			"msg": "pong",
-		})
-
-		if err != nil {
-			fmt.Println(err)
-		}
-	}
-}
-
-func (s *Server) handleMethod(c *websocket.Conn, m *Message) {
-	res, _ := s.methods[m.Method](m.Params)
-	err := c.WriteJSON(map[string]interface{}{
-		"msg":    "result",
-		"id":     m.Id,
-		"result": res,
-	})
+func readMessage(req Request) (Message, error) {
+	t, str, err := req.ReadMessage()
+	msg := Message{}
 
 	if err != nil {
-		fmt.Println(err)
+		return msg, err
 	}
 
-	err = c.WriteJSON(map[string]interface{}{
-		"msg":     "updated",
-		"methods": []string{m.Id},
-	})
-
-	if err != nil {
-		fmt.Println(err)
-	}
-}
-
-func readMessage(ws *websocket.Conn) (*Message, error) {
-	t, str, err := ws.ReadMessage()
-	msg := &Message{}
-
-	if err != nil {
-		// error reading message
-		return nil, err
+	if t != 1 {
+		err = errors.New("DDP does not supports binary streams yet")
+		return msg, err
 	}
 
-	if t != 1 {
-		// ignore binary data
-		err = errors.New("Error: DDP does not supports binary streams yet.")
-		return nil, err
+	if err := json.Unmarshal(str, &msg); err != nil {
+		return msg, err
 	}
 
-	err = json.Unmarshal(str, msg)
 	return msg, nil
 }