allow overriding charge point id resolution

Author: tanordheim

ws/mocks/mock_Server.go

@@ -97,6 +97,9 @@ type Server interface {
 	//
 	// Duplicates will be removed automatically.
 	AddSupportedSubprotocol(subProto string)
+	// SetChargePointIdResolver sets the callback function to use for resolving the charge point ID of a charger connecting to
+	// the websocket server. By default, this will just be the path in the URL used by the client.
+	SetChargePointIdResolver(resolver func(r *http.Request) (string, error))
 	// SetBasicAuthHandler enables HTTP Basic Authentication and requires clients to pass credentials.
 	// The handler function is called whenever a new client attempts to connect, to check for credentials correctness.
 	// The handler must return true if the credentials were correct, false otherwise.
@@ -127,21 +130,22 @@ type Server interface {
 //
 // Use the NewServer function to create a new server.
 type server struct {
-	connections         map[string]*webSocket
-	httpServer          *http.Server
-	messageHandler      func(ws Channel, data []byte) error
-	checkClientHandler  CheckClientHandler
-	newClientHandler    func(ws Channel)
-	disconnectedHandler func(ws Channel)
-	basicAuthHandler    func(username string, password string) bool
-	tlsCertificatePath  string
-	tlsCertificateKey   string
-	timeoutConfig       ServerTimeoutConfig
-	upgrader            websocket.Upgrader
-	errC                chan error
-	connMutex           sync.RWMutex
-	addr                *net.TCPAddr
-	httpHandler         *mux.Router
+	connections           map[string]*webSocket
+	httpServer            *http.Server
+	messageHandler        func(ws Channel, data []byte) error
+	chargePointIdResolver func(*http.Request) (string, error)
+	checkClientHandler    CheckClientHandler
+	newClientHandler      func(ws Channel)
+	disconnectedHandler   func(ws Channel)
+	basicAuthHandler      func(username string, password string) bool
+	tlsCertificatePath    string
+	tlsCertificateKey     string
+	timeoutConfig         ServerTimeoutConfig
+	upgrader              websocket.Upgrader
+	errC                  chan error
+	connMutex             sync.RWMutex
+	addr                  *net.TCPAddr
+	httpHandler           *mux.Router
 }
 
 // ServerOpt is a function that can be used to set options on a server during creation.
@@ -183,6 +187,10 @@ func NewServer(opts ...ServerOpt) Server {
 		timeoutConfig: NewServerTimeoutConfig(),
 		upgrader:      websocket.Upgrader{Subprotocols: []string{}},
 		httpHandler:   router,
+		chargePointIdResolver: func(r *http.Request) (string, error) {
+			url := r.URL
+			return path.Base(url.Path), nil
+		},
 	}
 	for _, o := range opts {
 		o(s)
@@ -220,6 +228,10 @@ func (s *server) AddSupportedSubprotocol(subProto string) {
 	s.upgrader.Subprotocols = append(s.upgrader.Subprotocols, subProto)
 }
 
+func (s *server) SetChargePointIdResolver(resolver func(r *http.Request) (string, error)) {
+	s.chargePointIdResolver = resolver
+}
+
 func (s *server) SetBasicAuthHandler(handler func(username string, password string) bool) {
 	s.basicAuthHandler = handler
 }
@@ -343,8 +355,12 @@ func (s *server) Write(webSocketId string, data []byte) error {
 
 func (s *server) wsHandler(w http.ResponseWriter, r *http.Request) {
 	responseHeader := http.Header{}
-	url := r.URL
-	id := path.Base(url.Path)
+	id, err := s.chargePointIdResolver(r)
+	if err != nil {
+		s.error(fmt.Errorf("failed to resolve charge point id"))
+		http.Error(w, "NotFound", http.StatusNotFound)
+		return
+	}
 	log.Debugf("handling new connection for %s from %s", id, r.RemoteAddr)
 	// Negotiate sub-protocol
 	clientSubProtocols := websocket.Subprotocols(r)

ws/server.go

@@ -297,6 +297,64 @@ func (s *WebSocketSuite) TestWebsocketEcho() {
 	}
 }
 
+func (s *WebSocketSuite) TestWebsocketChargePointIdResolver() {
+	connected := make(chan string)
+	s.server = newWebsocketServer(s.T(), func(data []byte) ([]byte, error) {
+		s.Fail("no message should be received from client!")
+		return nil, nil
+	})
+	s.server.SetChargePointIdResolver(func(*http.Request) (string, error) {
+		return "my-custom-id", nil
+	})
+	s.server.SetNewClientHandler(func(ws Channel) {
+		connected <- ws.ID()
+	})
+	go s.server.Start(serverPort, serverPath)
+	time.Sleep(500 * time.Millisecond)
+
+	// Test message
+	s.client = newWebsocketClient(s.T(), func(data []byte) ([]byte, error) {
+		s.Fail("no message should be received from server!")
+		return nil, nil
+	})
+
+	host := fmt.Sprintf("localhost:%v", serverPort)
+	u := url.URL{Scheme: "ws", Host: host, Path: testPath}
+	// Attempt to connect and expect the custom resolved charge point id
+	err := s.client.Start(u.String())
+	s.NoError(err)
+	result := <-connected
+	s.Equal("my-custom-id", result)
+}
+
+func (s *WebSocketSuite) TestWebsocketChargePointIdResolverFailure() {
+	s.server = newWebsocketServer(s.T(), func(data []byte) ([]byte, error) {
+		s.Fail("no message should be received from client!")
+		return nil, nil
+	})
+	s.server.SetChargePointIdResolver(func(*http.Request) (string, error) {
+		return "", fmt.Errorf("test error")
+	})
+	go s.server.Start(serverPort, serverPath)
+	time.Sleep(500 * time.Millisecond)
+
+	// Test message
+	s.client = newWebsocketClient(s.T(), func(data []byte) ([]byte, error) {
+		s.Fail("no message should be received from server!")
+		return nil, nil
+	})
+
+	host := fmt.Sprintf("localhost:%v", serverPort)
+	u := url.URL{Scheme: "ws", Host: host, Path: testPath}
+	// Attempt to connect and expect the custom resolved charge point id
+	err := s.client.Start(u.String())
+	s.Error(err)
+	httpErr, ok := err.(HttpConnectionError)
+	s.True(ok)
+	s.Equal(http.StatusNotFound, httpErr.HttpCode)
+	s.Equal("websocket: bad handshake", httpErr.Message)
+}
+
 func (s *WebSocketSuite) TestWebsocketBootRetries() {
 	verifyConnection := func(client *client, connected bool) {
 		maxAttempts := 20
@@ -1276,7 +1334,7 @@ func (s *WebSocketSuite) TestClientErrors() {
 	conn := s.server.connections[path.Base(testPath)]
 	s.NotNil(conn)
 	err = conn.WriteManual(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseUnsupportedData, ""))
-	//err = conn.connection.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseUnsupportedData, ""))
+	// err = conn.connection.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseUnsupportedData, ""))
 	s.NoError(err)
 	r = <-triggerC
 	s.NotNil(r)