WebSock interface r+d

server/connection.go

@@ -45,12 +45,16 @@ type connection struct {
 	Requests    []Request
 }
 
-// loop starts the reading and writing loops of the connection.
+// loop starts the reading and writing of the connection.
 func (conn *connection) loop(ctx context.Context) {
 	logger.Debug("New connection", "remote", conn.RemoteAddr())
-	if err, req := conn.registerClient(); err != nil {
+
+	// TODO said pedro
+	if err, _ := conn.registerClient(); err != nil {
+		//if err, req := conn.registerClient(); err != nil {
+
 		// Try to notify client
-		_ = conn.WriteJSON(NewErrorResponse(req.ID, err))
+		//_ = conn.WriteJSON(NewErrorResponse(req, err))
 		logger.Error("Error while login", "connection", conn.RemoteAddr(), "error", err)
 		return
 	}
@@ -78,7 +82,7 @@ func (conn *connection) processRead(ctx context.Context) {
 				return
 			default:
 				logger.Info("Error while reading", "connection", conn.RemoteAddr(), "error", err)
-				conn.pushChan <- NewErrorResponse(req.ID, err)
+				conn.pushChan <- NewErrorResponse(req, err)
 				continue
 			}
 		}
@@ -126,7 +130,7 @@ func (conn *connection) registerClient() (error, *Request) {
 	}
 
 	// authenticated, so setup
-	if err := conn.WriteJSON(NewOkResponse(req.ID, "Successfully registered")); err != nil {
+	if err := conn.WriteJSON(NewOkResponse(*req, "Successfully registered")); err != nil {
 		logger.Info("Error while writing", "connection", conn.RemoteAddr(), "request", "NewOkResponse", "error", err)
 	}
 	hub.registerChan <- conn

server/hub.go

@@ -128,7 +128,7 @@ func (h *Hub) dispatchObject(conn *connection) {
 	conn.Requests = conn.Requests[1:]
 	obj, ok := h.objects[req.Object]
 	if !ok {
-		conn.pushChan <- NewErrorResponse(req.ID, fmt.Errorf("unknown object %s", req.Object))
+		conn.pushChan <- NewErrorResponse(req, fmt.Errorf("unknown object %s", req.Object))
 		logger.Debug("Request for unknown object received", "submodule", "hub", "object", req.Object)
 		return
 	}

server/hub_option.go

@@ -26,17 +26,17 @@ import (
 type optionObject struct{}
 
 // dispatch processes requests made on the Option object
-func (s *optionObject) dispatch(h *Hub, req Request, conn *connection) {
+func (oo *optionObject) dispatch(h *Hub, req Request, conn *connection) {
 	ch := conn.pushChan
 	switch req.Action {
 	case "list":
 		logger.Debug("Request for option list received", "submodule", "hub", "object", req.Object, "action", req.Action)
 		opts, err := json.Marshal(sim.Options)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, opts)
+		ch <- NewResponse(req, opts)
 	case "set":
 		var setParams = struct {
 			Name  string      `json:"name"`
@@ -45,17 +45,17 @@ func (s *optionObject) dispatch(h *Hub, req Request, conn *connection) {
 		err := json.Unmarshal(req.Params, &setParams)
 		logger.Debug("Request for option set received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", req.Params)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("error on parameters: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("error on parameters: %s", err))
 			return
 		}
 		err = sim.Options.Set(setParams.Name, setParams.Value)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("error while setting option: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("error while setting option: %s", err))
 			return
 		}
-		ch <- NewOkResponse(req.ID, fmt.Sprintf("option %s set successfully to %v", setParams.Name, setParams.Value))
+		ch <- NewOkResponse(req, fmt.Sprintf("option %s set successfully to %v", setParams.Name, setParams.Value))
 	default:
-		ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
+		ch <- NewErrorResponse(req, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
 		logger.Debug("Request for unknown action received", "submodule", "hub", "object", req.Object, "action", req.Action)
 	}
 }

server/hub_place.go

@@ -28,44 +28,44 @@ import (
 type placeObject struct{}
 
 // dispatch processes requests made on the Place object
-func (s *placeObject) dispatch(h *Hub, req Request, conn *connection) {
+func (p *placeObject) dispatch(h *Hub, req Request, conn *connection) {
 	ch := conn.pushChan
 	switch req.Action {
 	case "list":
 		logger.Debug("Request for place list received", "submodule", "hub", "object", req.Object, "action", req.Action)
 		til, err := json.Marshal(sim.Places)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, til)
+		ch <- NewResponse(req, til)
 	case "show":
 		var idsParams = struct {
 			IDs []string `json:"ids"`
 		}{}
 		err := json.Unmarshal(req.Params, &idsParams)
 		logger.Debug("Request for place show received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", idsParams)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
 		tkis := make(map[string]*simulation.Place)
 		for _, id := range idsParams.IDs {
 			tsID, ok := sim.Places[id]
 			if !ok {
-				ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown place: %s", id))
+				ch <- NewErrorResponse(req, fmt.Errorf("unknown place: %s", id))
 				return
 			}
 			tkis[id] = tsID
 		}
 		tid, err := json.Marshal(tkis)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, tid)
+		ch <- NewResponse(req, tid)
 	default:
-		ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
+		ch <- NewErrorResponse(req, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
 		logger.Debug("Request for unknown action received", "submodule", "hub", "object", req.Object, "action", req.Action)
 	}
 }

server/hub_route.go

@@ -35,35 +35,35 @@ func (r *routeObject) dispatch(h *Hub, req Request, conn *connection) {
 		logger.Debug("Request for route list received", "submodule", "hub", "object", req.Object, "action", req.Action)
 		rtes, err := json.Marshal(sim.Routes)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, rtes)
+		ch <- NewResponse(req, rtes)
 	case "show":
 		var idsParams = struct {
 			IDs []string `json:"ids"`
 		}{}
 		err := json.Unmarshal(req.Params, &idsParams)
 		logger.Debug("Request for route show received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", idsParams)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
 		rtes := make(map[string]*simulation.Route)
 		for _, id := range idsParams.IDs {
 			rte, ok := sim.Routes[id]
 			if !ok {
-				ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown route: %s", id))
+				ch <- NewErrorResponse(req, fmt.Errorf("unknown route: %s", id))
 				return
 			}
 			rtes[id] = rte
 		}
 		rte, err := json.Marshal(rtes)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, rte)
+		ch <- NewResponse(req, rte)
 	case "activate":
 		var actParams = struct {
 			ID         string `json:"id"`
@@ -72,43 +72,43 @@ func (r *routeObject) dispatch(h *Hub, req Request, conn *connection) {
 		err := json.Unmarshal(req.Params, &actParams)
 		logger.Debug("Request for route activate received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", actParams)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
 		rte, ok := sim.Routes[actParams.ID]
 		if !ok {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown route: %s", actParams.ID))
+			ch <- NewErrorResponse(req, fmt.Errorf("unknown route: %s", actParams.ID))
 			return
 		}
 		err = rte.Activate(actParams.Persistent)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("cannot activate route %s: %s", actParams.ID, err))
+			ch <- NewErrorResponse(req, fmt.Errorf("cannot activate route %s: %s", actParams.ID, err))
 			return
 		}
-		ch <- NewOkResponse(req.ID, fmt.Sprintf("Route %s activated successfully", actParams.ID))
+		ch <- NewOkResponse(req, fmt.Sprintf("Route %s activated successfully", actParams.ID))
 	case "deactivate":
 		var idParams = struct {
 			ID string `json:"id"`
 		}{}
 		err := json.Unmarshal(req.Params, &idParams)
 		logger.Debug("Request for route deactivate received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", idParams)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
 		rte, ok := sim.Routes[idParams.ID]
 		if !ok {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown route: %s", idParams.ID))
+			ch <- NewErrorResponse(req, fmt.Errorf("unknown route: %s", idParams.ID))
 			return
 		}
 		err = rte.Deactivate()
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("cannot deactivate route %s: %s", idParams.ID, err))
+			ch <- NewErrorResponse(req, fmt.Errorf("cannot deactivate route %s: %s", idParams.ID, err))
 			return
 		}
-		ch <- NewOkResponse(req.ID, fmt.Sprintf("Route %s deactivated successfully", idParams.ID))
+		ch <- NewOkResponse(req, fmt.Sprintf("Route %s deactivated successfully", idParams.ID))
 	default:
-		ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
+		ch <- NewErrorResponse(req, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
 		logger.Debug("Request for unknown action received", "submodule", "hub", "object", req.Object, "action", req.Action)
 	}
 }

server/hub_server.go

@@ -29,32 +29,37 @@ type serverObject struct{}
 func (s *serverObject) dispatch(h *Hub, req Request, conn *connection) {
 	ch := conn.pushChan
 	switch req.Action {
+
 	case "register":
-		ch <- NewErrorResponse(req.ID, fmt.Errorf("can't call register when already registered"))
+		ch <- NewErrorResponse(req, fmt.Errorf("can't call register when already registered"))
 		logger.Warn("Request for second register received", "submodule", "hub", "object", req.Object, "action", req.Action)
+
 	case "addListener":
 		logger.Debug("Request for addListener received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", req.Params)
 		if err := h.addRegistryEntry(req, conn); err != nil {
-			ch <- NewErrorResponse(req.ID, err)
+			ch <- NewErrorResponse(req, err)
 			return
 		}
-		ch <- NewOkResponse(req.ID, "Listener added successfully")
+		ch <- NewOkResponse(req, "Listener added successfully")
+
 	case "removeListener":
 		logger.Debug("Request for removeListener received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", req.Params)
 		if err := h.removeRegistryEntry(req, conn); err != nil {
-			ch <- NewErrorResponse(req.ID, err)
+			ch <- NewErrorResponse(req, err)
 			return
 		}
-		ch <- NewOkResponse(req.ID, "Listener removed successfully")
+		ch <- NewOkResponse(req, "Listener removed successfully")
+
 	case "renotify":
 		logger.Debug("Request for renotify received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", req.Params)
 		if err := h.renotifyClient(req, conn); err != nil {
-			ch <- NewErrorResponse(req.ID, err)
+			ch <- NewErrorResponse(req, err)
 			return
 		}
-		ch <- NewOkResponse(req.ID, "Renotify request taken into account")
+		ch <- NewOkResponse(req, "Renotify request taken into account")
+
 	default:
-		ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
+		ch <- NewErrorResponse(req, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
 		logger.Debug("Request for unknown action received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", req.Params)
 	}
 }

server/hub_service.go

@@ -31,41 +31,44 @@ type serviceObject struct{}
 func (s *serviceObject) dispatch(h *Hub, req Request, conn *connection) {
 	ch := conn.pushChan
 	switch req.Action {
+
 	case "list":
 		logger.Debug("Request for service list received", "submodule", "hub", "object", req.Object, "action", req.Action)
 		sl, err := json.Marshal(sim.Services)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, sl)
+		ch <- NewResponse(req, sl)
+
 	case "show":
 		var idsParams = struct {
 			IDs []string `json:"ids"`
 		}{}
 		err := json.Unmarshal(req.Params, &idsParams)
 		logger.Debug("Request for service show received", "submodule", "hub", "object", req.Object, "action", req.Action, "params", idsParams)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
 		sl := make(map[string]*simulation.Service)
 		for _, id := range idsParams.IDs {
 			sld, ok := sim.Services[id]
 			if !ok {
-				ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown service: %s", id))
+				ch <- NewErrorResponse(req, fmt.Errorf("unknown service: %s", id))
 				return
 			}
 			sl[id] = sld
 		}
 		tid, err := json.Marshal(sl)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, tid)
+		ch <- NewResponse(req, tid)
+
 	default:
-		ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
+		ch <- NewErrorResponse(req, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
 		logger.Debug("Request for unknown action received", "submodule", "hub", "object", req.Object, "action", req.Action)
 	}
 }

server/hub_simulation.go

@@ -32,26 +32,26 @@ func (s *simulationObject) dispatch(h *Hub, req Request, conn *connection) {
 	switch req.Action {
 	case "start":
 		sim.Start()
-		ch <- NewOkResponse(req.ID, "Simulation started successfully")
+		ch <- NewOkResponse(req, "Simulation started successfully")
 	case "pause":
 		sim.Pause()
-		ch <- NewOkResponse(req.ID, "Simulation paused successfully")
+		ch <- NewOkResponse(req, "Simulation paused successfully")
 	case "isStarted":
 		j, err := json.Marshal(sim.IsStarted())
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, RawJSON(j))
+		ch <- NewResponse(req, RawJSON(j))
 	case "dump":
 		data, err := json.Marshal(sim)
 		if err != nil {
-			ch <- NewErrorResponse(req.ID, fmt.Errorf("internal error: %s", err))
+			ch <- NewErrorResponse(req, fmt.Errorf("internal error: %s", err))
 			return
 		}
-		ch <- NewResponse(req.ID, data)
+		ch <- NewResponse(req, data)
 	default:
-		ch <- NewErrorResponse(req.ID, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
+		ch <- NewErrorResponse(req, fmt.Errorf("unknown action %s/%s", req.Object, req.Action))
 		logger.Debug("Request for unknown action received", "submodule", "hub", "object", req.Object, "action", req.Action)
 	}
 }