fix logging and server addr.

server/internal/http/legacy/handler.go

@@ -3,7 +3,6 @@ package legacy
 import (
 	"errors"
 	"fmt"
-	"log"
 	"net/http"
 
 	oldEvent "github.com/demodesk/neko/internal/http/legacy/event"
@@ -14,6 +13,8 @@ import (
 	"github.com/demodesk/neko/pkg/types/message"
 	"github.com/demodesk/neko/pkg/utils"
 	"github.com/gorilla/websocket"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
 )
 
 var (
@@ -32,19 +33,22 @@ var (
 )
 
 type LegacyHandler struct {
+	logger     zerolog.Logger
+	serverAddr string
 }
 
 func New() *LegacyHandler {
 	// Init
 
-	return &LegacyHandler{}
+	return &LegacyHandler{
+		logger:     log.With().Str("module", "legacy").Logger(),
+		serverAddr: "127.0.0.1:8080",
+	}
 }
 
 func (h *LegacyHandler) Route(r types.Router) {
-	log.Println("legacy handler route")
-
 	r.Get("/ws", func(w http.ResponseWriter, r *http.Request) error {
-		s := newSession("http://127.0.0.1:8080")
+		s := newSession(h.logger, h.serverAddr)
 
 		// create a new websocket connection
 		connClient, err := DefaultUpgrader.Upgrade(w, r, nil)
@@ -57,28 +61,35 @@ func (h *LegacyHandler) Route(r types.Router) {
 		s.connClient = connClient
 
 		// create a new session
+		username := r.URL.Query().Get("username")
 		password := r.URL.Query().Get("password")
-		token, err := s.create(password)
+		token, err := s.create(username, password)
 		if err != nil {
-			log.Printf("couldn't create a new session: %v", err)
+			h.logger.Error().Err(err).Msg("couldn't create a new session")
+
 			s.toClient(&oldMessage.SystemMessage{
 				Event:   oldEvent.SYSTEM_DISCONNECT,
 				Title:   "couldn't create a new session",
 				Message: err.Error(),
 			})
+
+			// we can't return HTTP error here because the connection is already upgraded
 			return nil
 		}
 		defer s.destroy()
 
 		// dial to the remote backend
-		connBackend, _, err := DefaultDialer.Dial("ws://127.0.0.1:8080/api/ws?token="+token, nil)
+		connBackend, _, err := DefaultDialer.Dial("ws://"+h.serverAddr+"/api/ws?token="+token, nil)
 		if err != nil {
-			log.Printf("couldn't dial to the remote backend: %v", err)
+			h.logger.Error().Err(err).Msg("couldn't dial to the remote backend")
+
 			s.toClient(&oldMessage.SystemMessage{
 				Event:   oldEvent.SYSTEM_DISCONNECT,
 				Title:   "couldn't dial to the remote backend",
 				Message: err.Error(),
 			})
+
+			// we can't return HTTP error here because the connection is already upgraded
 			return nil
 		}
 		defer connBackend.Close()
@@ -86,12 +97,15 @@ func (h *LegacyHandler) Route(r types.Router) {
 
 		// request signal
 		if err = s.toBackend(event.SIGNAL_REQUEST, message.SignalRequest{}); err != nil {
-			log.Printf("couldn't request signal: %v", err)
+			h.logger.Error().Err(err).Msg("couldn't request signal")
+
 			s.toClient(&oldMessage.SystemMessage{
 				Event:   oldEvent.SYSTEM_DISCONNECT,
 				Title:   "couldn't request signal",
 				Message: err.Error(),
 			})
+
+			// we can't return HTTP error here because the connection is already upgraded
 			return nil
 		}
 
@@ -120,6 +134,8 @@ func (h *LegacyHandler) Route(r types.Router) {
 					}
 
 					if errors.Is(err, ErrBackendRespone) {
+						h.logger.Error().Err(err).Msg("backend response error")
+
 						s.toClient(&oldMessage.SystemMessage{
 							Event:   oldEvent.SYSTEM_ERROR,
 							Title:   "backend response error",
@@ -130,7 +146,7 @@ func (h *LegacyHandler) Route(r types.Router) {
 						errc <- err
 						break
 					} else {
-						log.Printf("websocketproxy: %v", err)
+						h.logger.Error().Err(err).Msg("couldn't rewrite text message")
 					}
 				}
 			}
@@ -151,7 +167,7 @@ func (h *LegacyHandler) Route(r types.Router) {
 		}
 
 		if e, ok := err.(*websocket.CloseError); !ok || e.Code == websocket.CloseAbnormalClosure {
-			log.Printf(message, err)
+			h.logger.Error().Err(err).Msg(message)
 		}
 
 		return nil

server/internal/http/legacy/session.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
 
 	oldTypes "github.com/demodesk/neko/internal/http/legacy/types"
@@ -13,6 +12,7 @@ import (
 	"github.com/demodesk/neko/internal/api"
 	"github.com/demodesk/neko/pkg/types"
 	"github.com/gorilla/websocket"
+	"github.com/rs/zerolog"
 )
 
 var (
@@ -21,7 +21,9 @@ var (
 )
 
 type session struct {
-	url     string
+	logger     zerolog.Logger
+	serverAddr string
+
 	id      string
 	token   string
 	profile types.MemberProfile
@@ -37,11 +39,12 @@ type session struct {
 	connBackend *websocket.Conn
 }
 
-func newSession(url string) *session {
+func newSession(logger zerolog.Logger, serverAddr string) *session {
 	return &session{
-		url:      url,
+		logger:     logger,
-		client:   http.DefaultClient,
+		serverAddr: serverAddr,
-		sessions: make(map[string]*oldTypes.Member),
+		client:     http.DefaultClient,
+		sessions:   make(map[string]*oldTypes.Member),
 	}
 }
 
@@ -51,7 +54,7 @@ func (s *session) apiReq(method, path string, request, response any) error {
 		return err
 	}
 
-	req, err := http.NewRequest(method, s.url+path, bytes.NewReader(body))
+	req, err := http.NewRequest(method, "http://"+s.serverAddr+path, bytes.NewReader(body))
 	if err != nil {
 		return err
 	}
@@ -85,6 +88,11 @@ func (s *session) apiReq(method, path string, request, response any) error {
 		return nil
 	}
 
+	if response == nil {
+		io.Copy(io.Discard, res.Body)
+		return nil
+	}
+
 	return json.NewDecoder(res.Body).Decode(response)
 }
 
@@ -126,12 +134,11 @@ func (s *session) toBackend(event string, payload any) error {
 	return nil
 }
 
-func (s *session) create(password string) (string, error) {
+func (s *session) create(username, password string) (string, error) {
 	data := api.SessionDataPayload{}
 
-	// pefrom login with arbitrary username that will be changed later
 	err := s.apiReq(http.MethodPost, "/api/login", api.SessionLoginPayload{
-		Username: "admin",
+		Username: username,
 		Password: password,
 	}, &data)
 	if err != nil {
@@ -142,8 +149,9 @@ func (s *session) create(password string) (string, error) {
 	s.token = data.Token
 	s.profile = data.Profile
 
+	// if Cookie auth, the token will be empty
 	if s.token == "" {
-		return "", fmt.Errorf("token not found")
+		return "", fmt.Errorf("token not found - make sure you are not using Cookie auth on the server")
 	}
 
 	return data.Token, nil
@@ -155,6 +163,6 @@ func (s *session) destroy() {
 	// logout session
 	err := s.apiReq(http.MethodPost, "/api/logout", nil, nil)
 	if err != nil {
-		log.Println("failed to logout session:", err)
+		s.logger.Error().Err(err).Msg("failed to logout")
 	}
 }