Added match handler that dispatches match/* requests to subhandlers.

Also added New...() functions to handlers to hide their initialization
process a little bit

Author: Zbynek Novotny

TODO

@@ -1 +1 @@
-Nuffin' to see here
+Empty

handlers/leaderboard_handler.go

@@ -12,6 +12,12 @@ type LeaderboardHandler struct {
 	core *core.Core
 }
 
+// NewLeaderboardHandler returns a pointer
+// to a new leaderboard handler instance
+func NewLeaderboardHandler(c *core.Core) *LeaderboardHandler {
+	return &LeaderboardHandler{core: c}
+}
+
 // ProcessRequest process the client's request and prepares
 // an appropriate response
 func (h *LeaderboardHandler) ProcessRequest(resp http.ResponseWriter, req *http.Request) {

handlers/login_handler.go

@@ -23,6 +23,12 @@ type LoginHandler struct {
 	core *core.Core
 }
 
+// NewLoginHandler creates a pointer to a new
+// instance of the login request handler structure
+func NewLoginHandler(c *core.Core) *LoginHandler {
+	return &LoginHandler{core: c}
+}
+
 // ProcessRequest handles the login POST request
 func (h *LoginHandler) ProcessRequest(resp http.ResponseWriter, req *http.Request) {
 	if req.Method != "POST" {

handlers/main_dispatcher.go

@@ -10,10 +10,10 @@ import (
 // and distributes to them the incoming requests
 type MainDispatcher struct {
 	core   *core.Core
-	login  LoginHandler
-	mlist  MatchlistHandler
-	lboard LeaderboardHandler
-	mjoin  MatchJoinHandler
+	login  *LoginHandler
+	mlist  *MatchlistHandler
+	lboard *LeaderboardHandler
+	match  *MatchHandler
 	// TODO Add join handler
 }
 
@@ -22,10 +22,10 @@ type MainDispatcher struct {
 func NewMainDispatcher(c *core.Core) *MainDispatcher {
 	return &MainDispatcher{
 		core:   c,
-		login:  LoginHandler{core: c},
-		mlist:  MatchlistHandler{core: c},
-		lboard: LeaderboardHandler{core: c},
-		mjoin:  MatchJoinHandler{core: c},
+		login:  NewLoginHandler(c),
+		mlist:  NewMatchlistHandler(c),
+		lboard: NewLeaderboardHandler(c),
+		match:  NewMatchHandler(c),
 	}
 }
 
@@ -41,7 +41,7 @@ func (dispatcher *MainDispatcher) ServeHTTP(resp http.ResponseWriter, req *http.
 	case "leaderboards":
 		dispatcher.lboard.ProcessRequest(resp, req)
 	case "match":
-		dispatcher.mjoin.ProcessRequest(resp, req)
+		dispatcher.match.ProcessRequest(resp, req)
 	default:
 		http.Error(resp, "Resource not found", http.StatusNotFound)
 	}

handlers/match_handler.go

@@ -0,0 +1,40 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/mrclayman/rest_api_test/core"
+)
+
+// MatchHandler structure represents a handler
+// processing REST/WS requests regarding match
+// joining and match event processing
+type MatchHandler struct {
+	core *core.Core
+	join *MatchJoinHandler
+	room *MatchRoomHandler
+}
+
+// NewMatchHandler returns a pointer to a new
+// instance of the match request handler
+func NewMatchHandler(c *core.Core) *MatchHandler {
+	return &MatchHandler{
+		core: c,
+		join: NewMatchJoinHandler(c),
+		room: NewMatchRoomHandler(c),
+	}
+}
+
+// ProcessRequest inspects the incoming request and dispatches it
+// further to individual handlers based on the type of the request
+func (h *MatchHandler) ProcessRequest(resp http.ResponseWriter, req *http.Request) {
+	var action string
+	switch action, req.URL.Path = SplitPath(req.URL.Path); action {
+	case "join":
+		h.join.ProcessRequest(resp, req)
+	case "room":
+		h.room.ProcessRequest(resp, req)
+	default:
+		http.Error(resp, "Resource '"+action+"' not found", http.StatusNotFound)
+	}
+}

handlers/match_join_handler.go

@@ -23,6 +23,12 @@ type MatchJoinHandler struct {
 	core *core.Core
 }
 
+// NewMatchJoinHandler returns a pointer to a new
+// instance of the match join request handler
+func NewMatchJoinHandler(c *core.Core) *MatchJoinHandler {
+	return &MatchJoinHandler{core: c}
+}
+
 // ProcessRequest processes the user's request
 // and generates an appropriate response
 func (h *MatchJoinHandler) ProcessRequest(resp http.ResponseWriter, req *http.Request) {
@@ -31,14 +37,7 @@ func (h *MatchJoinHandler) ProcessRequest(resp http.ResponseWriter, req *http.Re
 		return
 	}
 
-	// Joining a match requires a reference to a particular
-	// resource, check the URL to see if it is really there
-	var action string
-	action, req.URL.Path = SplitPath(req.URL.Path)
-	if action != "join" {
-		http.Error(resp, "Resource not found", http.StatusNotFound)
-		return
-	}
+
 
 	// Parse and process the request
 	var join joinRequest

handlers/match_room_handler.go

@@ -0,0 +1,39 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/gorilla/websocket"
+	"github.com/mrclayman/rest_api_test/core"
+)
+
+// MatchRoomHandler handles WebSocket requests
+// from a player that has previously joined
+// a match
+type MatchRoomHandler struct {
+	core     *core.Core
+	upgrader websocket.Upgrader
+}
+
+// NewMatchRoomHandler returns a pointer to a
+// new instance of the match room request handler
+func NewMatchRoomHandler(c *core.Core) *MatchRoomHandler {
+	return &MatchRoomHandler{
+		core:     c,
+		upgrader: websocket.Upgrader{},
+	}
+}
+
+// ProcessRequest processes the WebSocket request
+// from the player and creates an appropriate response
+func (h *MatchRoomHandler) ProcessRequest(resp http.ResponseWriter, req *http.Request) {
+	// Obtain the connection object from the request
+	conn, err := h.upgrader.Upgrade(resp, req, nil)
+	if err != nil {
+		http.Error(resp, "Failed to obtain connection from request: "+err.Error(), http.StatusInternalServerError)
+	}
+
+	defer conn.Close()
+
+	// TODO Finish the implementation
+}

handlers/matchlist_handler.go

@@ -12,6 +12,12 @@ type MatchlistHandler struct {
 	core *core.Core
 }
 
+// NewMatchlistHandler returns a pointer to a new
+// matchlist handler instance
+func NewMatchlistHandler(c *core.Core) *MatchlistHandler {
+	return &MatchlistHandler{core: c}
+}
+
 // ProcessRequest processes the incoming request and creates
 // an appropriate response
 func (h *MatchlistHandler) ProcessRequest(resp http.ResponseWriter, req *http.Request) {

handlers/util.go

@@ -59,11 +59,11 @@ func WriteJSONToResponse(resp http.ResponseWriter, in interface{}) error {
 	return err
 }
 
-// getSingleValueFromGetArgs obtains a single value from
+// getValueFromGET obtains a single value from
 // the request's GET arguments. It is expected that exactly
 // one value is present in the arguments and that the GET
 // arguments have been parsed beforehand using ParseForm()
-func getSingleValueFromGetArgs(req *http.Request, name string) (string, bool) {
+func getValueFromGET(req *http.Request, name string) (string, bool) {
 	value := req.Form.Get(name)
 	var ok bool
 	if len(value) > 0 {
@@ -82,15 +82,15 @@ func GetPlayerDataFromGetArgs(req *http.Request) (core.PlayerID, core.AuthToken,
 	token := core.InvalidAuthToken
 	var err error
 
-	if strPlayerID, ok := getSingleValueFromGetArgs(req, "id"); !ok {
+	if strPlayerID, ok := getValueFromGET(req, "id"); !ok {
 		return core.InvalidPlayerID, core.InvalidAuthToken,
 			RequestError{"Failed to obtain player ID from request"}
 	} else if playerID, err = core.StringToPlayerID(strPlayerID); err != nil {
 		return core.InvalidPlayerID, core.InvalidAuthToken,
 			RequestError{"Failed to convert argument to player ID"}
 	}
 
-	if strToken, ok := getSingleValueFromGetArgs(req, "token"); !ok {
+	if strToken, ok := getValueFromGET(req, "token"); !ok {
 		return core.InvalidPlayerID, core.InvalidAuthToken,
 			RequestError{"Failed to obtain player's authentication token from request"}
 	} else {