From 45c90ce9c27e46d8733ee0a8caed1a6d5ef19137 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20=C5=A0ediv=C3=BD?= Date: Wed, 24 Jul 2024 23:41:32 +0200 Subject: [PATCH] fix logging and server addr. --- server/internal/http/legacy/handler.go | 40 ++++++++++++++++++-------- server/internal/http/legacy/session.go | 32 +++++++++++++-------- 2 files changed, 48 insertions(+), 24 deletions(-) diff --git a/server/internal/http/legacy/handler.go b/server/internal/http/legacy/handler.go index e1688e7d..5fdf08b6 100644 --- a/server/internal/http/legacy/handler.go +++ b/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 diff --git a/server/internal/http/legacy/session.go b/server/internal/http/legacy/session.go index 6df1661e..df0463c9 100644 --- a/server/internal/http/legacy/session.go +++ b/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, - client: http.DefaultClient, - sessions: make(map[string]*oldTypes.Member), + logger: logger, + serverAddr: serverAddr, + 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") } }