3pp-mirror/neko
1
0
Fork 0
mirror of https://github.com/m1k1o/neko.git synced 2025-05-16 02:27:27 +02:00
Code Issues Projects Releases Packages Wiki Activity

fix logging and server addr.

Browse source
This commit is contained in:
Miroslav Šedivý 2024-07-24 23:41:32 +02:00
parent 679157ef6d
commit 45c90ce9c2
2 changed files with 48 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

40
server/internal/http/legacy/handler.go
View file

@ -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

32
server/internal/http/legacy/session.go
View file

@ -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")
}
}