From d83d0b5b36047551530a19ad4ea4b451e0b4ae47 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 12:25:45 +0200 Subject: [PATCH 01/10] update log inside non refactored part --- be1-go/cli/cli.go | 117 ++++++++---------- be1-go/internal/logger/logger.go | 2 +- be1-go/internal/network/server.go | 6 +- be1-go/internal/network/socket/socket_impl.go | 35 ++---- 4 files changed, 67 insertions(+), 93 deletions(-) diff --git a/be1-go/cli/cli.go b/be1-go/cli/cli.go index 72eca494ed..6ce464c627 100644 --- a/be1-go/cli/cli.go +++ b/be1-go/cli/cli.go @@ -5,8 +5,13 @@ import ( "encoding/base64" "encoding/json" "fmt" + "github.com/fsnotify/fsnotify" + "github.com/gorilla/websocket" "github.com/rs/zerolog" + "github.com/urfave/cli/v2" + "go.dedis.ch/kyber/v3" "golang.org/x/exp/slices" + "golang.org/x/xerrors" "net/url" "os" "popstellar/internal/crypto" @@ -17,15 +22,6 @@ import ( oldHub "popstellar/internal/old/hub" "sync" "time" - - "github.com/rs/zerolog/log" - "go.dedis.ch/kyber/v3" - - "github.com/gorilla/websocket" - - "github.com/fsnotify/fsnotify" - "github.com/urfave/cli/v2" - "golang.org/x/xerrors" ) const ( @@ -54,35 +50,10 @@ type ServerConfig struct { DatabasePath string `json:"database-path"` } -func (s *ServerConfig) newHub(l *zerolog.Logger) (oldHub.Hub, error) { - // compute the client server address if it wasn't provided - if s.ClientAddress == "" { - s.ClientAddress = fmt.Sprintf("ws://%s:%d/client", s.PublicAddress, s.ClientPort) - } - // compute the server server address if it wasn't provided - if s.ServerAddress == "" { - s.ServerAddress = fmt.Sprintf("ws://%s:%d/server", s.PublicAddress, s.ServerPort) - } - - var ownerPubKey kyber.Point = nil - err := ownerKey(s.PublicKey, &ownerPubKey) - if err != nil { - return nil, err - } - - hub, err := hub.New(s.DatabasePath, ownerPubKey, s.ClientAddress, s.ServerAddress) - - if err != nil { - return nil, err - } - - return hub, nil -} - // Serve parses the CLI arguments and spawns a hub and a websocket server for // the server func Serve(cliCtx *cli.Context) error { - poplog := logger.Logger + l := logger.Logger configFilePath := cliCtx.String("config-file") var serverConfig ServerConfig @@ -105,7 +76,7 @@ func Serve(cliCtx *cli.Context) error { } } - h, err := serverConfig.newHub(&poplog) + h, err := serverConfig.newHub(l) if err != nil { return err } @@ -114,13 +85,11 @@ func Serve(cliCtx *cli.Context) error { h.Start() // Start websocket server for clients - clientSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ClientPort, socket.ClientSocketType, - poplog.With().Str("role", "client websocket").Logger()) + clientSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ClientPort, socket.ClientSocketType, l) clientSrv.Start() // Start a websocket server for remote servers - serverSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ServerPort, socket.ServerSocketType, - poplog.With().Str("role", "server websocket").Logger()) + serverSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ServerPort, socket.ServerSocketType, l) serverSrv.Start() // create wait group which waits for goroutines to finish @@ -144,7 +113,7 @@ func Serve(cliCtx *cli.Context) error { } // start watching goroutine - go watchConfigFile(watcher, configFilePath, &serverConfig.OtherServers, updatedServersChan) + go watchConfigFile(watcher, configFilePath, &serverConfig.OtherServers, updatedServersChan, l) } // map to keep track of the connection status of the servers @@ -155,7 +124,7 @@ func Serve(cliCtx *cli.Context) error { } wg.Add(1) - go serverConnectionLoop(h, wg, done, serverConfig.OtherServers, updatedServersChan, &connectedServers) + go serverConnectionLoop(h, wg, done, serverConfig.OtherServers, updatedServersChan, &connectedServers, l) // Wait for a Ctrl-C err = network.WaitAndShutdownServers(cliCtx.Context, nil, clientSrv, serverSrv) @@ -180,18 +149,38 @@ func Serve(cliCtx *cli.Context) error { select { case <-channsClosed: case <-time.After(time.Second * 10): - poplog.Error().Msg("channs didn't close after timeout, exiting") + l.Error().Msg("channs didn't close after timeout, exiting") } return nil } +func (s *ServerConfig) newHub(l zerolog.Logger) (oldHub.Hub, error) { + // compute the client server address if it wasn't provided + if s.ClientAddress == "" { + s.ClientAddress = fmt.Sprintf("ws://%s:%d/client", s.PublicAddress, s.ClientPort) + } + // compute the server server address if it wasn't provided + if s.ServerAddress == "" { + s.ServerAddress = fmt.Sprintf("ws://%s:%d/server", s.PublicAddress, s.ServerPort) + } + + var ownerPubKey kyber.Point = nil + err := ownerKey(s.PublicKey, &ownerPubKey, l) + if err != nil { + return nil, err + } + + return hub.New(s.DatabasePath, ownerPubKey, s.ClientAddress, s.ServerAddress) +} + // serverConnectionLoop tries to connect to the remote servers following an exponential backoff strategy // it also listens for updates in the other-servers field and tries to connect to the new servers -func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, otherServers []string, updatedServersChan chan []string, connectedServers *map[string]bool) { +func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, otherServers []string, + updatedServersChan chan []string, connectedServers *map[string]bool, l zerolog.Logger) { // first connection to the servers serversToConnect := otherServers - _ = connectToServers(h, wg, done, serversToConnect, connectedServers) + _ = connectToServers(h, wg, done, serversToConnect, connectedServers, l) // define the delay between connection retries delay := connectionRetryInitialDelay @@ -203,8 +192,8 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, select { case <-ticker.C: // try to connect to servers - log.Info().Msgf("Trying to connect to servers: %v", serversToConnect) - err := connectToServers(h, wg, done, serversToConnect, connectedServers) + l.Info().Msgf("Trying to connect to servers: %v", serversToConnect) + err := connectToServers(h, wg, done, serversToConnect, connectedServers, l) if err != nil { increaseDelay(&delay) ticker.Reset(delay) @@ -215,9 +204,9 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, delay = connectionRetryInitialDelay ticker.Reset(delay) serversToConnect = newServersList - _ = connectToServers(h, wg, done, serversToConnect, connectedServers) + _ = connectToServers(h, wg, done, serversToConnect, connectedServers, l) case <-done: - log.Info().Msg("Stopping the server connection loop") + l.Info().Msg("Stopping the server connection loop") wg.Done() return } @@ -226,17 +215,18 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, // connectToServers updates the connection status of the servers and tries to connect to the ones that are not connected // it returns an error if at least one connection fails -func connectToServers(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, servers []string, connectedServers *map[string]bool) error { +func connectToServers(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, servers []string, + connectedServers *map[string]bool, l zerolog.Logger) error { updateServersState(servers, connectedServers) var returnErr error for serverAddress, connected := range *connectedServers { if !connected { - err := connectToSocket(serverAddress, h, wg, done) + err := connectToSocket(serverAddress, h, wg, done, l) if err == nil { (*connectedServers)[serverAddress] = true } else { returnErr = err - log.Error().Msgf("failed to connect to server %s: %v", serverAddress, err) + l.Error().Msgf("failed to connect to server %s: %v", serverAddress, err) } } } @@ -245,11 +235,7 @@ func connectToServers(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, serv // connectToSocket establishes a connection to another server's server // endpoint. -func connectToSocket(address string, h oldHub.Hub, - wg *sync.WaitGroup, done chan struct{}) error { - - poplog := logger.Logger - +func connectToSocket(address string, h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, l zerolog.Logger) error { urlString := fmt.Sprintf("ws://%s/server", address) u, err := url.Parse(urlString) if err != nil { @@ -261,10 +247,10 @@ func connectToSocket(address string, h oldHub.Hub, return xerrors.Errorf("failed to dial to %s: %v", u.String(), err) } - poplog.Info().Msgf("connected to server at %s", urlString) + l.Info().Msgf("connected to server at %s", urlString) remoteSocket := socket.NewServerSocket(h.Receiver(), - h.OnSocketClose(), ws, wg, done, poplog) + h.OnSocketClose(), ws, wg, done, l) wg.Add(2) go remoteSocket.WritePump() @@ -280,7 +266,7 @@ func connectToSocket(address string, h oldHub.Hub, return nil } -func ownerKey(pk string, point *kyber.Point) error { +func ownerKey(pk string, point *kyber.Point, l zerolog.Logger) error { if pk != "" { *point = crypto.Suite.Point() // decode public key and unmarshal public key @@ -294,9 +280,9 @@ func ownerKey(pk string, point *kyber.Point) error { return xerrors.Errorf("failed to unmarshal public key: %v", err) } - log.Info().Msg("The owner public key has been specified, only " + pk + " can create LAO") + l.Info().Msg("The owner public key has been specified, only " + pk + " can create LAO") } else { - log.Info().Msg("No public key specified for the owner, everyone can create LAO.") + l.Info().Msg("No public key specified for the owner, everyone can create LAO.") } return nil @@ -360,14 +346,15 @@ func startWithFlags(cliCtx *cli.Context) (ServerConfig, error) { // watchConfigFile watches the config file for changes, updates the other servers list in the config if necessary // and sends the updated other servers list to the updatedServersChan so that the connection to servers loop can // connect to them and update their connection status -func watchConfigFile(watcher *fsnotify.Watcher, configFilePath string, otherServersField *[]string, updatedServersChan chan []string) { +func watchConfigFile(watcher *fsnotify.Watcher, configFilePath string, otherServersField *[]string, + updatedServersChan chan []string, l zerolog.Logger) { for event := range watcher.Events { if event.Op&fsnotify.Write == fsnotify.Write { updatedConfig, err := loadConfig(configFilePath) if err != nil { - log.Error().Msgf("Could not load config file: %v", err) + l.Error().Msgf("Could not load config file: %v", err) } else if newServersAdded(updatedConfig.OtherServers, otherServersField) { - log.Info().Msgf("New servers list: %v", updatedConfig.OtherServers) + l.Info().Msgf("New servers list: %v", updatedConfig.OtherServers) // update the other servers field of the config *otherServersField = updatedConfig.OtherServers // send the updated other servers list to the channel diff --git a/be1-go/internal/logger/logger.go b/be1-go/internal/logger/logger.go index 35a3ae1e81..e32cc7a9c1 100644 --- a/be1-go/internal/logger/logger.go +++ b/be1-go/internal/logger/logger.go @@ -36,7 +36,7 @@ var ShortSHA = "unknown" // level. const EnvLogLevel = "LLVL" -const defaultLevel = zerolog.DebugLevel +const defaultLevel = zerolog.InfoLevel func init() { lvl := os.Getenv(EnvLogLevel) diff --git a/be1-go/internal/network/server.go b/be1-go/internal/network/server.go index bbf661ff21..f031ad3a19 100644 --- a/be1-go/internal/network/server.go +++ b/be1-go/internal/network/server.go @@ -49,7 +49,11 @@ type Server struct { // // endpoint. Please use the Start() method to start // listening for connections. func NewServer(hub hub.Hub, addr string, port int, st socket.SocketType, log zerolog.Logger) *Server { - log = log.With().Str("role", "server").Logger() + if st == socket.ClientSocketType { + log = log.With().Str("server", "client").Logger() + } else { + log = log.With().Str("server", "server").Logger() + } server := &Server{ hub: hub, diff --git a/be1-go/internal/network/socket/socket_impl.go b/be1-go/internal/network/socket/socket_impl.go index 455a80c2a0..6c66280b3b 100644 --- a/be1-go/internal/network/socket/socket_impl.go +++ b/be1-go/internal/network/socket/socket_impl.go @@ -81,15 +81,14 @@ func (s *baseSocket) ReadPump() { _, message, err := s.conn.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) { - s.log.Err(err). - Str("socket", s.conn.RemoteAddr().String()). - Msg("connection dropped unexpectedly") + s.log.Err(err).Msg("connection dropped unexpectedly") } else { s.log.Info().Msg("closing the read pump") } break } + s.log.Info().RawJSON("received", message).Msg("") msg := IncomingMessage{ Socket: s, Message: message, @@ -134,6 +133,7 @@ func (s *baseSocket) WritePump() { } w.Write(message) + s.log.Info().RawJSON("sent", message).Msg("") if err := w.Close(); err != nil { s.log.Err(err).Msg("failed to close writer") @@ -155,10 +155,6 @@ func (s *baseSocket) WritePump() { // Send allows sending a serialized message to the socket. func (s *baseSocket) Send(msg []byte) { - s.log.Info(). - Str("to", s.conn.RemoteAddr().String()). - Str("msg", string(msg)). - Msg("send generic msg") s.send <- msg } @@ -185,11 +181,6 @@ func (s *baseSocket) SendError(id *int, err error) { return } - s.log.Info(). - Str("to", s.conn.RemoteAddr().String()). - Str("msg", string(answerBuf)). - Msg("send error") - s.send <- answerBuf } @@ -223,11 +214,6 @@ func (s *baseSocket) SendPopError(id *int, err error) { return } - s.log.Info(). - Str("to", s.conn.RemoteAddr().String()). - Str("msg", string(answerBuf)). - Msg("send error") - s.send <- answerBuf } @@ -278,10 +264,6 @@ func (s *baseSocket) SendResult(id int, res []mmessage.Message, missingMessagesB return } - s.log.Info(). - Str("to", s.id). - Str("msg", string(answerBuf)). - Msg("send result") s.send <- answerBuf } @@ -289,8 +271,13 @@ func newBaseSocket(socketType SocketType, receiver chan<- IncomingMessage, closedSockets chan<- string, conn *websocket.Conn, wg *sync.WaitGroup, done chan struct{}, log zerolog.Logger, ) *baseSocket { + id := xid.New().String() + log = log.With().Dict("socket", zerolog.Dict(). + Str("ID", id). + Str("IP", conn.RemoteAddr().String())).Logger() + return &baseSocket{ - id: xid.New().String(), + id: id, socketType: socketType, receiver: receiver, closedSockets: closedSockets, @@ -312,8 +299,6 @@ func NewClientSocket(receiver chan<- IncomingMessage, closedSockets chan<- string, conn *websocket.Conn, wg *sync.WaitGroup, done chan struct{}, log zerolog.Logger, ) *ClientSocket { - log = log.With().Str("role", "client socket").Logger() - return &ClientSocket{ baseSocket: newBaseSocket(ClientSocketType, receiver, closedSockets, conn, wg, done, log), @@ -330,8 +315,6 @@ func NewServerSocket(receiver chan<- IncomingMessage, closedSockets chan<- string, conn *websocket.Conn, wg *sync.WaitGroup, done chan struct{}, log zerolog.Logger, ) *ServerSocket { - log = log.With().Str("role", "server socket").Logger() - return &ServerSocket{ baseSocket: newBaseSocket(ServerSocketType, receiver, closedSockets, conn, wg, done, log), From 82cd216a87f5d92b98e1c5d2b63e49d98ce870c7 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 13:00:44 +0200 Subject: [PATCH 02/10] add log inside states --- be1-go/cli/cli.go | 56 ++++++++++++++-------------- be1-go/internal/hub/hub.go | 53 +++++++++++++------------- be1-go/internal/state/config.go | 5 ++- be1-go/internal/state/hub_params.go | 5 ++- be1-go/internal/state/peers.go | 5 ++- be1-go/internal/state/queries.go | 25 ++++++------- be1-go/internal/state/sockets.go | 8 ++-- be1-go/internal/state/subscribers.go | 5 ++- 8 files changed, 89 insertions(+), 73 deletions(-) diff --git a/be1-go/cli/cli.go b/be1-go/cli/cli.go index 6ce464c627..2013f08956 100644 --- a/be1-go/cli/cli.go +++ b/be1-go/cli/cli.go @@ -53,7 +53,7 @@ type ServerConfig struct { // Serve parses the CLI arguments and spawns a hub and a websocket server for // the server func Serve(cliCtx *cli.Context) error { - l := logger.Logger + log := logger.Logger configFilePath := cliCtx.String("config-file") var serverConfig ServerConfig @@ -76,7 +76,7 @@ func Serve(cliCtx *cli.Context) error { } } - h, err := serverConfig.newHub(l) + h, err := serverConfig.newHub(log) if err != nil { return err } @@ -85,11 +85,11 @@ func Serve(cliCtx *cli.Context) error { h.Start() // Start websocket server for clients - clientSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ClientPort, socket.ClientSocketType, l) + clientSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ClientPort, socket.ClientSocketType, log) clientSrv.Start() // Start a websocket server for remote servers - serverSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ServerPort, socket.ServerSocketType, l) + serverSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ServerPort, socket.ServerSocketType, log) serverSrv.Start() // create wait group which waits for goroutines to finish @@ -113,7 +113,7 @@ func Serve(cliCtx *cli.Context) error { } // start watching goroutine - go watchConfigFile(watcher, configFilePath, &serverConfig.OtherServers, updatedServersChan, l) + go watchConfigFile(watcher, configFilePath, &serverConfig.OtherServers, updatedServersChan, log) } // map to keep track of the connection status of the servers @@ -124,7 +124,7 @@ func Serve(cliCtx *cli.Context) error { } wg.Add(1) - go serverConnectionLoop(h, wg, done, serverConfig.OtherServers, updatedServersChan, &connectedServers, l) + go serverConnectionLoop(h, wg, done, serverConfig.OtherServers, updatedServersChan, &connectedServers, log) // Wait for a Ctrl-C err = network.WaitAndShutdownServers(cliCtx.Context, nil, clientSrv, serverSrv) @@ -149,13 +149,13 @@ func Serve(cliCtx *cli.Context) error { select { case <-channsClosed: case <-time.After(time.Second * 10): - l.Error().Msg("channs didn't close after timeout, exiting") + log.Error().Msg("channs didn't close after timeout, exiting") } return nil } -func (s *ServerConfig) newHub(l zerolog.Logger) (oldHub.Hub, error) { +func (s *ServerConfig) newHub(log zerolog.Logger) (oldHub.Hub, error) { // compute the client server address if it wasn't provided if s.ClientAddress == "" { s.ClientAddress = fmt.Sprintf("ws://%s:%d/client", s.PublicAddress, s.ClientPort) @@ -166,21 +166,21 @@ func (s *ServerConfig) newHub(l zerolog.Logger) (oldHub.Hub, error) { } var ownerPubKey kyber.Point = nil - err := ownerKey(s.PublicKey, &ownerPubKey, l) + err := ownerKey(s.PublicKey, &ownerPubKey, log) if err != nil { return nil, err } - return hub.New(s.DatabasePath, ownerPubKey, s.ClientAddress, s.ServerAddress) + return hub.New(s.DatabasePath, ownerPubKey, s.ClientAddress, s.ServerAddress, log) } // serverConnectionLoop tries to connect to the remote servers following an exponential backoff strategy // it also listens for updates in the other-servers field and tries to connect to the new servers func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, otherServers []string, - updatedServersChan chan []string, connectedServers *map[string]bool, l zerolog.Logger) { + updatedServersChan chan []string, connectedServers *map[string]bool, log zerolog.Logger) { // first connection to the servers serversToConnect := otherServers - _ = connectToServers(h, wg, done, serversToConnect, connectedServers, l) + _ = connectToServers(h, wg, done, serversToConnect, connectedServers, log) // define the delay between connection retries delay := connectionRetryInitialDelay @@ -192,8 +192,8 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, select { case <-ticker.C: // try to connect to servers - l.Info().Msgf("Trying to connect to servers: %v", serversToConnect) - err := connectToServers(h, wg, done, serversToConnect, connectedServers, l) + log.Info().Msgf("Trying to connect to servers: %v", serversToConnect) + err := connectToServers(h, wg, done, serversToConnect, connectedServers, log) if err != nil { increaseDelay(&delay) ticker.Reset(delay) @@ -204,9 +204,9 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, delay = connectionRetryInitialDelay ticker.Reset(delay) serversToConnect = newServersList - _ = connectToServers(h, wg, done, serversToConnect, connectedServers, l) + _ = connectToServers(h, wg, done, serversToConnect, connectedServers, log) case <-done: - l.Info().Msg("Stopping the server connection loop") + log.Info().Msg("Stopping the server connection loop") wg.Done() return } @@ -216,17 +216,17 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, // connectToServers updates the connection status of the servers and tries to connect to the ones that are not connected // it returns an error if at least one connection fails func connectToServers(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, servers []string, - connectedServers *map[string]bool, l zerolog.Logger) error { + connectedServers *map[string]bool, log zerolog.Logger) error { updateServersState(servers, connectedServers) var returnErr error for serverAddress, connected := range *connectedServers { if !connected { - err := connectToSocket(serverAddress, h, wg, done, l) + err := connectToSocket(serverAddress, h, wg, done, log) if err == nil { (*connectedServers)[serverAddress] = true } else { returnErr = err - l.Error().Msgf("failed to connect to server %s: %v", serverAddress, err) + log.Error().Msgf("failed to connect to server %s: %v", serverAddress, err) } } } @@ -235,7 +235,7 @@ func connectToServers(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, serv // connectToSocket establishes a connection to another server's server // endpoint. -func connectToSocket(address string, h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, l zerolog.Logger) error { +func connectToSocket(address string, h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, log zerolog.Logger) error { urlString := fmt.Sprintf("ws://%s/server", address) u, err := url.Parse(urlString) if err != nil { @@ -247,10 +247,10 @@ func connectToSocket(address string, h oldHub.Hub, wg *sync.WaitGroup, done chan return xerrors.Errorf("failed to dial to %s: %v", u.String(), err) } - l.Info().Msgf("connected to server at %s", urlString) + log.Info().Msgf("connected to server at %s", urlString) remoteSocket := socket.NewServerSocket(h.Receiver(), - h.OnSocketClose(), ws, wg, done, l) + h.OnSocketClose(), ws, wg, done, log) wg.Add(2) go remoteSocket.WritePump() @@ -266,7 +266,7 @@ func connectToSocket(address string, h oldHub.Hub, wg *sync.WaitGroup, done chan return nil } -func ownerKey(pk string, point *kyber.Point, l zerolog.Logger) error { +func ownerKey(pk string, point *kyber.Point, log zerolog.Logger) error { if pk != "" { *point = crypto.Suite.Point() // decode public key and unmarshal public key @@ -280,9 +280,9 @@ func ownerKey(pk string, point *kyber.Point, l zerolog.Logger) error { return xerrors.Errorf("failed to unmarshal public key: %v", err) } - l.Info().Msg("The owner public key has been specified, only " + pk + " can create LAO") + log.Info().Msg("The owner public key has been specified, only " + pk + " can create LAO") } else { - l.Info().Msg("No public key specified for the owner, everyone can create LAO.") + log.Info().Msg("No public key specified for the owner, everyone can create LAO.") } return nil @@ -347,14 +347,14 @@ func startWithFlags(cliCtx *cli.Context) (ServerConfig, error) { // and sends the updated other servers list to the updatedServersChan so that the connection to servers loop can // connect to them and update their connection status func watchConfigFile(watcher *fsnotify.Watcher, configFilePath string, otherServersField *[]string, - updatedServersChan chan []string, l zerolog.Logger) { + updatedServersChan chan []string, log zerolog.Logger) { for event := range watcher.Events { if event.Op&fsnotify.Write == fsnotify.Write { updatedConfig, err := loadConfig(configFilePath) if err != nil { - l.Error().Msgf("Could not load config file: %v", err) + log.Error().Msgf("Could not load config file: %v", err) } else if newServersAdded(updatedConfig.OtherServers, otherServersField) { - l.Info().Msgf("New servers list: %v", updatedConfig.OtherServers) + log.Info().Msgf("New servers list: %v", updatedConfig.OtherServers) // update the other servers field of the config *otherServersField = updatedConfig.OtherServers // send the updated other servers list to the channel diff --git a/be1-go/internal/hub/hub.go b/be1-go/internal/hub/hub.go index d373333b93..600800292f 100644 --- a/be1-go/internal/hub/hub.go +++ b/be1-go/internal/hub/hub.go @@ -2,6 +2,7 @@ package hub import ( "encoding/json" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/database/sqlite" @@ -29,7 +30,6 @@ import ( "popstellar/internal/handler/method/unsubscribe/hunsubscribe" "popstellar/internal/handler/query/hquery" "popstellar/internal/handler/query/mquery" - "popstellar/internal/logger" "popstellar/internal/network/socket" "popstellar/internal/state" "popstellar/internal/validation" @@ -90,16 +90,18 @@ type Hub struct { jsonRpcHandler JsonRpcHandler greetserverSender GreetServerSender rumorSender RumorSender + + log zerolog.Logger } -func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress string) (*Hub, error) { +func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress string, log zerolog.Logger) (*Hub, error) { // Initialize the in memory states - subs := state.NewSubscribers() - peers := state.NewPeers() - queries := state.NewQueries(&logger.Logger) - hubParams := state.NewHubParams() - sockets := state.NewSockets() + subs := state.NewSubscribers(log) + peers := state.NewPeers(log) + queries := state.NewQueries(log) + hubParams := state.NewHubParams(log) + sockets := state.NewSockets(log) // Initialize the database db, err := sqlite.NewSQLite(dbPath, true) @@ -121,7 +123,7 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st } // Create the in memory configuration state - conf := state.CreateConfig(ownerPubKey, serverPublicKey, serverSecretKey, clientAddress, serverAddress) + conf := state.CreateConfig(ownerPubKey, serverPublicKey, serverSecretKey, clientAddress, serverAddress, log) // Store the rumor with id 0 associated to the server if the database is empty err = db.StoreFirstRumor() @@ -207,6 +209,7 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st jsonRpcHandler: jsonRpcHandler, greetserverSender: greetserverHandler, rumorSender: rumorHandler, + log: log.With().Str("role", "hub").Logger(), } return hub, nil @@ -242,23 +245,23 @@ func (h *Hub) SendGreetServer(socket socket.Socket) error { func (h *Hub) runMessageReceiver() { defer h.wg.Done() - defer logger.Logger.Info().Msg("stopping hub") + defer h.log.Info().Msg("stopping hub") - logger.Logger.Info().Msg("starting hub") + h.log.Info().Msg("starting hub") for { - logger.Logger.Debug().Msg("waiting for a new message") + h.log.Debug().Msg("waiting for a new message") select { case incomingMessage := <-h.messageChan: - logger.Logger.Debug().Msg("start handling a message") + h.log.Debug().Msg("start handling a message") err := h.jsonRpcHandler.Handle(incomingMessage.Socket, incomingMessage.Message) if err != nil { - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } else { - logger.Logger.Debug().Msg("successfully handled a message") + h.log.Debug().Msg("successfully handled a message") } case socketID := <-h.closedSockets: - logger.Logger.Debug().Msgf("stopping the Socket " + socketID) + h.log.Debug().Msgf("stopping the Socket " + socketID) h.subs.UnsubscribeFromAll(socketID) case <-h.stop: return @@ -270,24 +273,24 @@ func (h *Hub) runRumorSender() { ticker := time.NewTicker(rumorDelay) defer ticker.Stop() defer h.wg.Done() - defer logger.Logger.Info().Msg("stopping rumor sender") + defer h.log.Info().Msg("stopping rumor sender") - logger.Logger.Info().Msg("starting rumor sender") + h.log.Info().Msg("starting rumor sender") for { select { case <-ticker.C: - logger.Logger.Debug().Msgf("sender rumor trigerred") + h.log.Debug().Msgf("sender rumor trigerred") err := h.tryToSendRumor() if err != nil { - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } case <-h.resetRumorSender: - logger.Logger.Debug().Msgf("sender rumor reset") + h.log.Debug().Msgf("sender rumor reset") ticker.Reset(rumorDelay) err := h.tryToSendRumor() if err != nil { - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } case <-h.stop: return @@ -301,7 +304,7 @@ func (h *Hub) tryToSendRumor() error { return err } if !ok { - logger.Logger.Debug().Msg("no new rumor to send") + h.log.Debug().Msg("no new rumor to send") return nil } @@ -314,16 +317,16 @@ func (h *Hub) runHeartbeat() { ticker := time.NewTicker(heartbeatDelay) defer ticker.Stop() defer h.wg.Done() - defer logger.Logger.Info().Msg("stopping heartbeat sender") + defer h.log.Info().Msg("stopping heartbeat sender") - logger.Logger.Info().Msg("starting heartbeat sender") + h.log.Info().Msg("starting heartbeat sender") for { select { case <-ticker.C: err := h.sendHeartbeat() if err != nil { - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } case <-h.stop: return diff --git a/be1-go/internal/state/config.go b/be1-go/internal/state/config.go index 0530a60ac7..aad3eeff69 100644 --- a/be1-go/internal/state/config.go +++ b/be1-go/internal/state/config.go @@ -2,6 +2,7 @@ package state import ( "encoding/base64" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "go.dedis.ch/kyber/v3/sign/schnorr" "popstellar/internal/crypto" @@ -14,16 +15,18 @@ type Config struct { serverSecretKey kyber.Scalar clientServerAddress string serverServerAddress string + log zerolog.Logger } func CreateConfig(ownerPubKey, serverPubKey kyber.Point, serverSecretKey kyber.Scalar, - clientServerAddress, serverServerAddress string) *Config { + clientServerAddress, serverServerAddress string, log zerolog.Logger) *Config { return &Config{ ownerPubKey: ownerPubKey, serverPubKey: serverPubKey, serverSecretKey: serverSecretKey, clientServerAddress: clientServerAddress, serverServerAddress: serverServerAddress, + log: log.With().Str("role", "config").Logger(), } } diff --git a/be1-go/internal/state/hub_params.go b/be1-go/internal/state/hub_params.go index 8d5e309446..a0f3bd90bf 100644 --- a/be1-go/internal/state/hub_params.go +++ b/be1-go/internal/state/hub_params.go @@ -1,6 +1,7 @@ package state import ( + "github.com/rs/zerolog" "popstellar/internal/network/socket" "sync" ) @@ -11,14 +12,16 @@ type HubParams struct { closedSockets chan string stop chan struct{} resetRumorSender chan struct{} + log zerolog.Logger } -func NewHubParams() *HubParams { +func NewHubParams(log zerolog.Logger) *HubParams { return &HubParams{ messageChan: make(chan socket.IncomingMessage), stop: make(chan struct{}), closedSockets: make(chan string), resetRumorSender: make(chan struct{}), + log: log.With().Str("role", "hub_params").Logger(), } } diff --git a/be1-go/internal/state/peers.go b/be1-go/internal/state/peers.go index 692a28ad9a..e2f7444679 100644 --- a/be1-go/internal/state/peers.go +++ b/be1-go/internal/state/peers.go @@ -1,6 +1,7 @@ package state import ( + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/method/greetserver/mgreetserver" "sync" @@ -16,13 +17,15 @@ type Peers struct { peersInfo map[string]mgreetserver.GreetServerParams // peersGreeted stores the peers that were greeted by the socket ID peersGreeted map[string]struct{} + log zerolog.Logger } // NewPeers creates a new Peers structure -func NewPeers() *Peers { +func NewPeers(log zerolog.Logger) *Peers { return &Peers{ peersInfo: make(map[string]mgreetserver.GreetServerParams), peersGreeted: make(map[string]struct{}), + log: log.With().Str("role", "peers").Logger(), } } diff --git a/be1-go/internal/state/queries.go b/be1-go/internal/state/queries.go index dd4c2105b7..343a511188 100644 --- a/be1-go/internal/state/queries.go +++ b/be1-go/internal/state/queries.go @@ -1,12 +1,11 @@ package state import ( + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/method/getmessagesbyid/mgetmessagesbyid" - method2 "popstellar/internal/handler/method/rumor/mrumor" + "popstellar/internal/handler/method/rumor/mrumor" "sync" - - "github.com/rs/zerolog" ) // Queries let the hub remember all queries that it sent to other servers @@ -17,21 +16,22 @@ type Queries struct { state map[int]bool // getMessagesByIdQueries stores the server's getMessagesByIds queries by their ID. getMessagesByIdQueries map[int]mgetmessagesbyid.GetMessagesById - getRumorQueries map[int]method2.Rumor + getRumorQueries map[int]mrumor.Rumor // nextID store the ID of the next query nextID int + // zerolog - log *zerolog.Logger + log zerolog.Logger } // NewQueries creates a new queries struct -func NewQueries(log *zerolog.Logger) *Queries { +func NewQueries(log zerolog.Logger) *Queries { return &Queries{ state: make(map[int]bool), getMessagesByIdQueries: make(map[int]mgetmessagesbyid.GetMessagesById), - getRumorQueries: make(map[int]method2.Rumor), - log: log, + getRumorQueries: make(map[int]mrumor.Rumor), + log: log.With().Str("role", "queries").Logger(), } } @@ -69,8 +69,7 @@ func (q *Queries) SetQueryReceived(id int) error { } if currentState { - q.log.Info().Msgf("query with id %d already answered", id) - return nil + return errors.NewDuplicateResourceError("query with id %d already answered", id) } q.state[id] = true @@ -86,7 +85,7 @@ func (q *Queries) AddQuery(id int, query mgetmessagesbyid.GetMessagesById) { q.state[id] = false } -func (q *Queries) AddRumorQuery(id int, query method2.Rumor) { +func (q *Queries) AddRumorQuery(id int, query mrumor.Rumor) { q.Lock() defer q.Unlock() @@ -103,13 +102,13 @@ func (q *Queries) IsRumorQuery(queryID int) bool { return ok } -func (q *Queries) GetRumorFromPastQuery(queryID int) (method2.Rumor, bool) { +func (q *Queries) GetRumorFromPastQuery(queryID int) (mrumor.Rumor, bool) { q.Lock() defer q.Unlock() rumor, ok := q.getRumorQueries[queryID] if !ok { - return method2.Rumor{}, false + return mrumor.Rumor{}, false } return rumor, true diff --git a/be1-go/internal/state/sockets.go b/be1-go/internal/state/sockets.go index d5b41e9214..607e092b13 100644 --- a/be1-go/internal/state/sockets.go +++ b/be1-go/internal/state/sockets.go @@ -2,18 +2,19 @@ package state import ( "fmt" + "github.com/rs/zerolog" "math/rand" - "popstellar/internal/logger" "popstellar/internal/network/socket" "sync" ) // NewSockets returns a new initialized Sockets -func NewSockets() *Sockets { +func NewSockets(log zerolog.Logger) *Sockets { return &Sockets{ rState: make(map[string]rumorState), socketIDs: make([]string, 0), store: make(map[string]socket.Socket), + log: log.With().Str("role", "sockets").Logger(), } } @@ -29,6 +30,7 @@ type Sockets struct { rState map[string]rumorState socketIDs []string store map[string]socket.Socket + log zerolog.Logger } func (s *Sockets) newRumorState(socket socket.Socket) rumorState { @@ -83,7 +85,7 @@ func (s *Sockets) SendRumor(socket socket.Socket, senderID string, rumorID int, } if rState.counter >= len(s.store) { - logger.Logger.Debug().Msgf("stop sending rumor because completed cycle") + s.log.Debug().Msgf("stop sending rumor because completed cycle") return } diff --git a/be1-go/internal/state/subscribers.go b/be1-go/internal/state/subscribers.go index 75f478dbc3..f5cb97e36e 100644 --- a/be1-go/internal/state/subscribers.go +++ b/be1-go/internal/state/subscribers.go @@ -2,6 +2,7 @@ package state import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/jsonrpc/mjsonrpc" "popstellar/internal/handler/message/mmessage" @@ -14,11 +15,13 @@ import ( type Subscribers struct { sync.RWMutex list map[string]map[string]socket.Socket + log zerolog.Logger } -func NewSubscribers() *Subscribers { +func NewSubscribers(log zerolog.Logger) *Subscribers { return &Subscribers{ list: make(map[string]map[string]socket.Socket), + log: log.With().Str("role", "subscribers").Logger(), } } From edc691c5a55eebd5336625f7e1f2201d00afef95 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 14:01:21 +0200 Subject: [PATCH 03/10] add log all modules --- be1-go/cli/cli_test.go | 6 ++- .../internal/handler/answer/hanswer/answer.go | 28 ++++++----- .../handler/answer/hanswer/answer_test.go | 6 +-- .../handler/channel/chirp/hchirp/chirp.go | 6 ++- .../channel/chirp/hchirp/chirp_test.go | 10 ++-- .../handler/channel/coin/hcoin/coin.go | 6 ++- .../handler/channel/coin/hcoin/coin_test.go | 8 ++- .../channel/election/helection/election.go | 6 ++- .../election/helection/election_test.go | 10 ++-- .../federation/hfederation/federation.go | 8 +-- .../federation/hfederation/federation_test.go | 50 ++++++++++++------- .../internal/handler/channel/lao/hlao/lao.go | 6 ++- .../handler/channel/lao/hlao/lao_test.go | 10 ++-- .../channel/reaction/hreaction/reaction.go | 6 ++- .../reaction/hreaction/reaction_test.go | 8 ++- .../handler/channel/root/hroot/root.go | 7 ++- .../handler/channel/root/hroot/root_test.go | 12 +++-- .../handler/jsonrpc/hjsonrpc/jsonrpc.go | 6 ++- .../handler/jsonrpc/hjsonrpc/jsonrpc_test.go | 4 +- .../handler/message/hmessage/message.go | 5 +- .../handler/message/hmessage/message_test.go | 4 +- .../method/catchup/hcatchup/catchup.go | 9 ++-- .../method/catchup/hcatchup/catchup_test.go | 4 +- .../hgetmessagesbyid/getmessagesbyid.go | 9 ++-- .../hgetmessagesbyid/getmessagesbyid_test.go | 4 +- .../greetserver/hgreetserver/greetserver.go | 5 +- .../hgreetserver/greetserver_test.go | 4 +- .../method/heartbeat/hheartbeat/heartbeat.go | 5 +- .../heartbeat/hheartbeat/heartbeat_test.go | 4 +- .../method/publish/hpublish/publish.go | 5 +- .../handler/method/rumor/hrumor/rumor.go | 6 ++- .../method/subscribe/hsubscribe/subscribe.go | 9 +++- .../subscribe/hsubscribe/subscribe_test.go | 4 +- .../unsubscribe/hunsubscribe/unsubscribe.go | 9 +++- .../hunsubscribe/unsubscribe_test.go | 4 +- be1-go/internal/handler/query/hquery/query.go | 5 +- .../handler/query/hquery/query_test.go | 4 +- be1-go/internal/hub/hub.go | 38 +++++++------- be1-go/internal/network/socket/socket_impl.go | 11 ++-- .../network/socket/socket_impl_test.go | 3 +- 40 files changed, 235 insertions(+), 119 deletions(-) diff --git a/be1-go/cli/cli_test.go b/be1-go/cli/cli_test.go index 52c6251a91..d0554248ca 100644 --- a/be1-go/cli/cli_test.go +++ b/be1-go/cli/cli_test.go @@ -52,7 +52,7 @@ func TestConnectToSocket(t *testing.T) { wh.Start() wg := &sync.WaitGroup{} - err = connectToSocket("localhost:9001", wh, wg, wDone) + err = connectToSocket("localhost:9001", wh, wg, wDone, log) require.NoError(t, err) err = remoteSrv.Shutdown() @@ -100,6 +100,8 @@ func TestLoadConfigFileWithInvalidAuthPort(t *testing.T) { // TestWatchConfigFile tests that a config file is watched correctly and the updated servers are received func TestWatchConfigFile(t *testing.T) { + log := zerolog.New(io.Discard) + // Load the config from the file serverConfig, err := loadConfig(validConfigWatcherPath) require.NoError(t, err) @@ -119,7 +121,7 @@ func TestWatchConfigFile(t *testing.T) { updatedServersChan := make(chan []string) // Start watching the config file - go watchConfigFile(watcher, validConfigWatcherPath, &serverConfig.OtherServers, updatedServersChan) + go watchConfigFile(watcher, validConfigWatcherPath, &serverConfig.OtherServers, updatedServersChan, log) defer func(watcher *fsnotify.Watcher) { require.NoError(t, watcher.Close()) }(watcher) diff --git a/be1-go/internal/handler/answer/hanswer/answer.go b/be1-go/internal/handler/answer/hanswer/answer.go index 9cd7f169b2..6fa9ee9f93 100644 --- a/be1-go/internal/handler/answer/hanswer/answer.go +++ b/be1-go/internal/handler/answer/hanswer/answer.go @@ -2,12 +2,12 @@ package hanswer import ( "encoding/json" + "github.com/rs/zerolog" "math/rand" "popstellar/internal/errors" "popstellar/internal/handler/answer/manswer" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/rumor/mrumor" - "popstellar/internal/logger" "popstellar/internal/network/socket" "sort" ) @@ -39,12 +39,14 @@ type Handlers struct { type Handler struct { queries Queries handlers Handlers + log zerolog.Logger } -func New(queries Queries, handlers Handlers) *Handler { +func New(queries Queries, handlers Handlers, log zerolog.Logger) *Handler { return &Handler{ queries: queries, handlers: handlers, + log: log.With().Str("module", "answer").Logger(), } } @@ -57,7 +59,7 @@ func (h *Handler) Handle(msg []byte) error { } if answerMsg.ID == nil { - logger.Logger.Info().Msg("received an answer with a null id") + h.log.Info().Msg("received an answer with a null id") return nil } @@ -67,14 +69,14 @@ func (h *Handler) Handle(msg []byte) error { } if answerMsg.Result == nil { - logger.Logger.Info().Msg("received an error, nothing to handle") + h.log.Info().Msg("received an error, nothing to handle") // don't send any error to avoid infinite error loop as a server will // send an error to another server that will create another error return nil } if answerMsg.Result.IsEmpty() { - logger.Logger.Info().Msg("expected isn't an answer to a popquery, nothing to handle") + h.log.Info().Msg("expected isn't an answer to a popquery, nothing to handle") return nil } @@ -94,26 +96,26 @@ func (h *Handler) handleRumorAnswer(msg manswer.Answer) error { return err } - logger.Logger.Debug().Msgf("received an answer to rumor query %d", *msg.ID) + h.log.Debug().Msgf("received an answer to rumor query %d", *msg.ID) if msg.Error != nil { - logger.Logger.Debug().Msgf("received an answer error to rumor query %d", *msg.ID) + h.log.Debug().Msgf("received an answer error to rumor query %d", *msg.ID) if msg.Error.Code != errors.DuplicateResourceErrorCode { - logger.Logger.Debug().Msgf("invalid error code to rumor query %d", *msg.ID) + h.log.Debug().Msgf("invalid error code to rumor query %d", *msg.ID) return nil } stop := rand.Float64() < continueMongering if stop { - logger.Logger.Debug().Msgf("stop mongering rumor query %d", *msg.ID) + h.log.Debug().Msgf("stop mongering rumor query %d", *msg.ID) return nil } - logger.Logger.Debug().Msgf("continue mongering rumor query %d", *msg.ID) + h.log.Debug().Msgf("continue mongering rumor query %d", *msg.ID) } - logger.Logger.Debug().Msgf("sender rumor need to continue sending query %d", *msg.ID) + h.log.Debug().Msgf("sender rumor need to continue sending query %d", *msg.ID) rumor, ok := h.queries.GetRumorFromPastQuery(*msg.ID) if !ok { return errors.NewInternalServerError("rumor query %d doesn't exist", *msg.ID) @@ -140,7 +142,7 @@ func (h *Handler) handleGetMessagesByIDAnswer(msg manswer.Answer) { } err = errors.NewJsonUnmarshalError(err.Error()) - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } if len(msgsByChan[channelID]) == 0 { @@ -176,7 +178,7 @@ func (h *Handler) tryToHandleMessages(msgsByChannel map[string]map[string]mmessa continue } - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } if len(msgsByChannel[channelID]) == 0 { diff --git a/be1-go/internal/handler/answer/hanswer/answer_test.go b/be1-go/internal/handler/answer/hanswer/answer_test.go index 8faedc96f4..88414f8adc 100644 --- a/be1-go/internal/handler/answer/hanswer/answer_test.go +++ b/be1-go/internal/handler/answer/hanswer/answer_test.go @@ -45,16 +45,16 @@ func (n *nullRumorSender) SendRumor(socket socket.Socket, rumor mrumor.Rumor) { func Test_handleMessagesByChannel(t *testing.T) { - l := zerolog.New(io.Discard) + log := zerolog.New(io.Discard) - queries := state.NewQueries(&l) + queries := state.NewQueries(log) answerHandlers := Handlers{ MessageHandler: &nullMessageHandler{}, RumorSender: &nullRumorSender{}, } - handler := New(queries, answerHandlers) + handler := New(queries, answerHandlers, log) type input struct { name string diff --git a/be1-go/internal/handler/channel/chirp/hchirp/chirp.go b/be1-go/internal/handler/channel/chirp/hchirp/chirp.go index ce1e9f8c30..80cb51f044 100644 --- a/be1-go/internal/handler/channel/chirp/hchirp/chirp.go +++ b/be1-go/internal/handler/channel/chirp/hchirp/chirp.go @@ -3,6 +3,7 @@ package hchirp import ( "encoding/base64" "encoding/json" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/errors" "popstellar/internal/handler/channel" @@ -34,15 +35,16 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(conf Config, subs Subscribers, - db Repository, schema *validation.SchemaValidator) *Handler { +func New(conf Config, subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ conf: conf, subs: subs, db: db, schema: schema, + log: log.With().Str("module", "chirp").Logger(), } } diff --git a/be1-go/internal/handler/channel/chirp/hchirp/chirp_test.go b/be1-go/internal/handler/channel/chirp/hchirp/chirp_test.go index 69f6356364..21b85da120 100644 --- a/be1-go/internal/handler/channel/chirp/hchirp/chirp_test.go +++ b/be1-go/internal/handler/channel/chirp/hchirp/chirp_test.go @@ -2,8 +2,10 @@ package hchirp import ( "encoding/base64" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "io" "popstellar/internal/crypto" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/chirp/hchirp/mocks" @@ -27,7 +29,9 @@ func Test_handleChannelChirp(t *testing.T) { contains string } - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) @@ -44,9 +48,9 @@ func Test_handleChannelChirp(t *testing.T) { serverSecretKey := crypto.Suite.Scalar().Pick(crypto.Suite.RandomStream()) serverPublicKey := crypto.Suite.Point().Mul(serverSecretKey, nil) - conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress") + conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress", log) - chirp := New(conf, subs, db, schema) + chirp := New(conf, subs, db, schema, log) sender := "3yPmdBu8DM7jT30IKqkPjuFFIHnubO0z4E0dV7dR4sY=" wrongSender := "3yPmdBu8DM7jT30IKqkPjuFFIHnubO0z4E0dV7dR4sK=" diff --git a/be1-go/internal/handler/channel/coin/hcoin/coin.go b/be1-go/internal/handler/channel/coin/hcoin/coin.go index 19d89db55c..1ca06365ae 100644 --- a/be1-go/internal/handler/channel/coin/hcoin/coin.go +++ b/be1-go/internal/handler/channel/coin/hcoin/coin.go @@ -2,6 +2,7 @@ package hcoin import ( "encoding/base64" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/coin/mcoin" @@ -22,14 +23,15 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(subs Subscribers, db Repository, - schema *validation.SchemaValidator) *Handler { +func New(subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ subs: subs, db: db, schema: schema, + log: log.With().Str("module", "coin").Logger(), } } diff --git a/be1-go/internal/handler/channel/coin/hcoin/coin_test.go b/be1-go/internal/handler/channel/coin/hcoin/coin_test.go index d18738a9bd..ae0083282a 100644 --- a/be1-go/internal/handler/channel/coin/hcoin/coin_test.go +++ b/be1-go/internal/handler/channel/coin/hcoin/coin_test.go @@ -4,7 +4,9 @@ import ( "embed" "encoding/base64" "encoding/json" + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/coin/hcoin/mocks" "popstellar/internal/handler/message/mmessage" @@ -27,14 +29,16 @@ type inputTestHandleChannelCoin struct { } func Test_handleChannelCoin(t *testing.T) { - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - coin := New(subs, db, schema) + coin := New(subs, db, schema, log) inputs := make([]inputTestHandleChannelCoin, 0) diff --git a/be1-go/internal/handler/channel/election/helection/election.go b/be1-go/internal/handler/channel/election/helection/election.go index 5329ce6f69..5a0f743bf8 100644 --- a/be1-go/internal/handler/channel/election/helection/election.go +++ b/be1-go/internal/handler/channel/election/helection/election.go @@ -6,6 +6,7 @@ import ( "encoding/binary" "encoding/json" "fmt" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/errors" @@ -75,15 +76,16 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(conf Config, subs Subscribers, - db Repository, schema *validation.SchemaValidator) *Handler { +func New(conf Config, subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ conf: conf, subs: subs, db: db, schema: schema, + log: log.With().Str("module", "election").Logger(), } } diff --git a/be1-go/internal/handler/channel/election/helection/election_test.go b/be1-go/internal/handler/channel/election/helection/election_test.go index 8be3134c4f..3737b812e8 100644 --- a/be1-go/internal/handler/channel/election/helection/election_test.go +++ b/be1-go/internal/handler/channel/election/helection/election_test.go @@ -3,9 +3,11 @@ package helection import ( "encoding/base64" "fmt" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "go.dedis.ch/kyber/v3" + "io" "popstellar/internal/crypto" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/election/helection/mocks" @@ -34,7 +36,9 @@ func Test_handleChannelElection(t *testing.T) { var args []input - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) @@ -51,9 +55,9 @@ func Test_handleChannelElection(t *testing.T) { serverSecretKey := crypto.Suite.Scalar().Pick(crypto.Suite.RandomStream()) serverPublicKey := crypto.Suite.Point().Mul(serverSecretKey, nil) - conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress") + conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress", log) - election := New(conf, subs, db, schema) + election := New(conf, subs, db, schema, log) laoID := base64.URLEncoding.EncodeToString([]byte("laoID")) electionID := base64.URLEncoding.EncodeToString([]byte("electionID")) diff --git a/be1-go/internal/handler/channel/federation/hfederation/federation.go b/be1-go/internal/handler/channel/federation/hfederation/federation.go index 3c3b4501a2..290008eb58 100644 --- a/be1-go/internal/handler/channel/federation/hfederation/federation.go +++ b/be1-go/internal/handler/channel/federation/hfederation/federation.go @@ -7,6 +7,7 @@ import ( "encoding/json" "fmt" "github.com/gorilla/websocket" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "go.dedis.ch/kyber/v3/sign/schnorr" "popstellar/internal/crypto" @@ -18,7 +19,6 @@ import ( "popstellar/internal/handler/method/publish/mpublish" method2 "popstellar/internal/handler/method/subscribe/msubscribe" "popstellar/internal/handler/query/mquery" - "popstellar/internal/logger" "popstellar/internal/network/socket" "popstellar/internal/validation" "strings" @@ -74,14 +74,16 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(hub Hub, subs Subscribers, db Repository, schema *validation.SchemaValidator) *Handler { +func New(hub Hub, subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ hub: hub, subs: subs, db: db, schema: schema, + log: log.With().Str("module", "federation").Logger(), } } @@ -457,7 +459,7 @@ func (h *Handler) connectTo(serverAddress string) (socket.Socket, error) { wg := h.hub.GetWaitGroup() stopChan := h.hub.GetStopChan() - client := socket.NewClientSocket(messageChan, closedSockets, ws, wg, stopChan, logger.Logger) + client := socket.NewClientSocket(messageChan, closedSockets, ws, wg, stopChan, h.log) wg.Add(2) diff --git a/be1-go/internal/handler/channel/federation/hfederation/federation_test.go b/be1-go/internal/handler/channel/federation/hfederation/federation_test.go index af8c96c271..36a02ceb53 100644 --- a/be1-go/internal/handler/channel/federation/hfederation/federation_test.go +++ b/be1-go/internal/handler/channel/federation/hfederation/federation_test.go @@ -6,8 +6,10 @@ import ( "encoding/json" "fmt" "github.com/gorilla/websocket" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "io" "net" "net/http" "popstellar/internal/handler/channel" @@ -37,13 +39,15 @@ func Test_handleChannelFederation(t *testing.T) { var args []input + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator2.GenerateKeyPair(t) organizer2Pk, _, organizer2Sk, _ := generator2.GenerateKeyPair(t) @@ -321,13 +325,15 @@ func Test_handleChannelFederation(t *testing.T) { } func Test_handleRequestChallenge(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator2.GenerateKeyPair(t) serverPk, _, serverSk, _ := generator2.GenerateKeyPair(t) @@ -372,13 +378,15 @@ func Test_handleRequestChallenge(t *testing.T) { } func Test_handleFederationExpect(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator2.GenerateKeyPair(t) organizer2Pk, _, _, _ := generator2.GenerateKeyPair(t) @@ -428,13 +436,15 @@ func Test_handleFederationExpect(t *testing.T) { } func Test_handleFederationInit(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator2.GenerateKeyPair(t) organizer2Pk, _, _, _ := generator2.GenerateKeyPair(t) @@ -506,13 +516,15 @@ func Test_handleFederationInit(t *testing.T) { } func Test_handleFederationChallenge(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator2.GenerateKeyPair(t) organizer2Pk, _, organizer2Sk, _ := generator2.GenerateKeyPair(t) @@ -609,13 +621,15 @@ func Test_handleFederationChallenge(t *testing.T) { } func Test_handleFederationResult(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator2.GenerateKeyPair(t) organizer2Pk, _, organizer2Sk, _ := generator2.GenerateKeyPair(t) diff --git a/be1-go/internal/handler/channel/lao/hlao/lao.go b/be1-go/internal/handler/channel/lao/hlao/lao.go index 9f1e7ab778..b7eb92c4a1 100644 --- a/be1-go/internal/handler/channel/lao/hlao/lao.go +++ b/be1-go/internal/handler/channel/lao/hlao/lao.go @@ -3,6 +3,7 @@ package hlao import ( "encoding/base64" "encoding/json" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/errors" @@ -70,15 +71,16 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(conf Config, subs Subscribers, - db Repository, schema *validation.SchemaValidator) *Handler { +func New(conf Config, subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ conf: conf, subs: subs, db: db, schema: schema, + log: log.With().Str("module", "lao").Logger(), } } diff --git a/be1-go/internal/handler/channel/lao/hlao/lao_test.go b/be1-go/internal/handler/channel/lao/hlao/lao_test.go index f699a1f99d..750c1aceba 100644 --- a/be1-go/internal/handler/channel/lao/hlao/lao_test.go +++ b/be1-go/internal/handler/channel/lao/hlao/lao_test.go @@ -2,9 +2,11 @@ package hlao import ( "encoding/base64" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "go.dedis.ch/kyber/v3" + "io" "popstellar/internal/crypto" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/lao/hlao/mocks" @@ -35,7 +37,9 @@ func Test_handleChannelLao(t *testing.T) { contains string } - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) @@ -52,9 +56,9 @@ func Test_handleChannelLao(t *testing.T) { serverSecretKey := crypto.Suite.Scalar().Pick(crypto.Suite.RandomStream()) serverPublicKey := crypto.Suite.Point().Mul(serverSecretKey, nil) - conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress") + conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress", log) - handler := New(conf, subs, db, schema) + handler := New(conf, subs, db, schema, log) var args []input diff --git a/be1-go/internal/handler/channel/reaction/hreaction/reaction.go b/be1-go/internal/handler/channel/reaction/hreaction/reaction.go index d83d099242..37ca30e5a5 100644 --- a/be1-go/internal/handler/channel/reaction/hreaction/reaction.go +++ b/be1-go/internal/handler/channel/reaction/hreaction/reaction.go @@ -2,6 +2,7 @@ package hreaction import ( "encoding/base64" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/reaction/mreaction" @@ -29,14 +30,15 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(subs Subscribers, db Repository, - schema *validation.SchemaValidator) *Handler { +func New(subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ subs: subs, db: db, schema: schema, + log: log.With().Str("module", "reaction").Logger(), } } diff --git a/be1-go/internal/handler/channel/reaction/hreaction/reaction_test.go b/be1-go/internal/handler/channel/reaction/hreaction/reaction_test.go index 8728b1d63d..000b15198c 100644 --- a/be1-go/internal/handler/channel/reaction/hreaction/reaction_test.go +++ b/be1-go/internal/handler/channel/reaction/hreaction/reaction_test.go @@ -1,7 +1,9 @@ package hreaction import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/reaction/hreaction/mocks" "popstellar/internal/handler/message/mmessage" @@ -22,14 +24,16 @@ func Test_handleChannelReaction(t *testing.T) { contains string } - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - reactionHandler := New(subs, db, schema) + reactionHandler := New(subs, db, schema, log) sender := "3yPmdBu8DM7jT30IKqkPjuFFIHnubO0z4E0dV7dR4sY=" //wrongSender := "3yPmdBu8DM7jT30IKqkPjuFFIHnubO0z4E0dV7dR4sK=" diff --git a/be1-go/internal/handler/channel/root/hroot/root.go b/be1-go/internal/handler/channel/root/hroot/root.go index 72d482513a..ae35640fb3 100644 --- a/be1-go/internal/handler/channel/root/hroot/root.go +++ b/be1-go/internal/handler/channel/root/hroot/root.go @@ -3,6 +3,7 @@ package hroot import ( "encoding/base64" "encoding/json" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/errors" @@ -51,16 +52,18 @@ type Handler struct { peers Peers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(config Config, db Repository, - subs Subscribers, peers Peers, schema *validation.SchemaValidator) *Handler { +func New(config Config, db Repository, subs Subscribers, peers Peers, + schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ conf: config, subs: subs, peers: peers, db: db, schema: schema, + log: log.With().Str("module", "root").Logger(), } } diff --git a/be1-go/internal/handler/channel/root/hroot/root_test.go b/be1-go/internal/handler/channel/root/hroot/root_test.go index 8dbf528fe9..b22340f2ac 100644 --- a/be1-go/internal/handler/channel/root/hroot/root_test.go +++ b/be1-go/internal/handler/channel/root/hroot/root_test.go @@ -3,8 +3,10 @@ package hroot import ( "encoding/base64" "fmt" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "io" "popstellar/internal/crypto" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/root/hroot/mocks" @@ -31,6 +33,8 @@ func Test_handleChannelRoot(t *testing.T) { contains string } + log := zerolog.New(io.Discard) + organizerBuf, err := base64.URLEncoding.DecodeString(ownerPubBuf64) require.NoError(t, err) @@ -42,16 +46,16 @@ func Test_handleChannelRoot(t *testing.T) { serverPublicKey := crypto.Suite.Point().Mul(serverSecretKey, nil) conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, - "clientAddress", "serverAddress") + "clientAddress", "serverAddress", log) db := mocks.NewRepository(t) - subs := state.NewSubscribers() - peers := state.NewPeers() + subs := state.NewSubscribers(log) + peers := state.NewPeers(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - rootHandler := New(conf, db, subs, peers, schema) + rootHandler := New(conf, db, subs, peers, schema, log) var args []input diff --git a/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc.go b/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc.go index 4623ca63b2..f7a0997353 100644 --- a/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc.go +++ b/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc.go @@ -1,6 +1,7 @@ package hjsonrpc import ( + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/jsonrpc/mjsonrpc" "popstellar/internal/network/socket" @@ -19,13 +20,16 @@ type Handler struct { schema *validation.SchemaValidator queryHandler QueryHandler answerHandler AnswerHandler + log zerolog.Logger } -func New(schema *validation.SchemaValidator, queryHandler QueryHandler, answerHandler AnswerHandler) *Handler { +func New(schema *validation.SchemaValidator, queryHandler QueryHandler, + answerHandler AnswerHandler, log zerolog.Logger) *Handler { return &Handler{ schema: schema, queryHandler: queryHandler, answerHandler: answerHandler, + log: log.With().Str("module", "jsonrpc").Logger(), } } diff --git a/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc_test.go b/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc_test.go index c692281219..2eb0aacb68 100644 --- a/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc_test.go +++ b/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc_test.go @@ -2,7 +2,9 @@ package hjsonrpc import ( "encoding/base64" + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/network/socket" "popstellar/internal/network/socket/mocks" generator2 "popstellar/internal/test/generator" @@ -35,7 +37,7 @@ func Test_handleIncomingMessage(t *testing.T) { queryHandler := &nullQueryHandler{} answerHandler := &nullAnswerHandler{} - handler := New(schema, queryHandler, answerHandler) + handler := New(schema, queryHandler, answerHandler, zerolog.New(io.Discard)) args := make([]input, 0) diff --git a/be1-go/internal/handler/message/hmessage/message.go b/be1-go/internal/handler/message/hmessage/message.go index eda77da3ba..f5a971c1bb 100644 --- a/be1-go/internal/handler/message/hmessage/message.go +++ b/be1-go/internal/handler/message/hmessage/message.go @@ -1,6 +1,7 @@ package hmessage import ( + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/message/mmessage" @@ -32,12 +33,14 @@ type DataHandlers struct { type Handler struct { db Repository handlers DataHandlers + log zerolog.Logger } -func New(db Repository, handlers DataHandlers) *Handler { +func New(db Repository, handlers DataHandlers, log zerolog.Logger) *Handler { return &Handler{ db: db, handlers: handlers, + log: log.With().Str("module", "message").Logger(), } } diff --git a/be1-go/internal/handler/message/hmessage/message_test.go b/be1-go/internal/handler/message/hmessage/message_test.go index 6cc438a0aa..c9c10cf646 100644 --- a/be1-go/internal/handler/message/hmessage/message_test.go +++ b/be1-go/internal/handler/message/hmessage/message_test.go @@ -2,8 +2,10 @@ package hmessage import ( "encoding/base64" + "github.com/rs/zerolog" "github.com/stretchr/testify/require" "golang.org/x/xerrors" + "io" "popstellar/internal/handler/channel" "popstellar/internal/handler/message/hmessage/mocks" "popstellar/internal/handler/message/mmessage" @@ -26,7 +28,7 @@ func Test_handleChannel(t *testing.T) { Federation: dataHandler, } - msgHandler := New(db, subHandlers) + msgHandler := New(db, subHandlers, zerolog.New(io.Discard)) _, publicBuf, private, _ := generator.GenerateKeyPair(t) sender := base64.URLEncoding.EncodeToString(publicBuf) diff --git a/be1-go/internal/handler/method/catchup/hcatchup/catchup.go b/be1-go/internal/handler/method/catchup/hcatchup/catchup.go index 2c7b659a07..9e50a55277 100644 --- a/be1-go/internal/handler/method/catchup/hcatchup/catchup.go +++ b/be1-go/internal/handler/method/catchup/hcatchup/catchup.go @@ -2,6 +2,7 @@ package hcatchup import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/catchup/mcatchup" @@ -14,12 +15,14 @@ type Repository interface { } type Handler struct { - db Repository + db Repository + log zerolog.Logger } -func New(db Repository) *Handler { +func New(db Repository, log zerolog.Logger) *Handler { return &Handler{ - db: db, + db: db, + log: log.With().Str("module", "catchup").Logger(), } } diff --git a/be1-go/internal/handler/method/catchup/hcatchup/catchup_test.go b/be1-go/internal/handler/method/catchup/hcatchup/catchup_test.go index 25dc878b01..2e8300e177 100644 --- a/be1-go/internal/handler/method/catchup/hcatchup/catchup_test.go +++ b/be1-go/internal/handler/method/catchup/hcatchup/catchup_test.go @@ -1,8 +1,10 @@ package hcatchup import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" "golang.org/x/xerrors" + "io" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/catchup/hcatchup/mocks" mocks2 "popstellar/internal/network/socket/mocks" @@ -13,7 +15,7 @@ import ( func Test_handleCatchUp(t *testing.T) { db := mocks.NewRepository(t) - handler := New(db) + handler := New(db, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid.go b/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid.go index 4956a27862..311cf44ab4 100644 --- a/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid.go +++ b/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid.go @@ -2,6 +2,7 @@ package hgetmessagesbyid import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/getmessagesbyid/mgetmessagesbyid" @@ -13,12 +14,14 @@ type Repository interface { } type Handler struct { - db Repository + db Repository + log zerolog.Logger } -func New(db Repository) *Handler { +func New(db Repository, log zerolog.Logger) *Handler { return &Handler{ - db: db, + db: db, + log: log.With().Str("module", "getmessagesbyid").Logger(), } } diff --git a/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid_test.go b/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid_test.go index afab9d0549..90c3bc801f 100644 --- a/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid_test.go +++ b/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid_test.go @@ -1,8 +1,10 @@ package hgetmessagesbyid import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" "golang.org/x/xerrors" + "io" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/getmessagesbyid/hgetmessagesbyid/mocks" mocks2 "popstellar/internal/network/socket/mocks" @@ -13,7 +15,7 @@ import ( func Test_handleGetMessagesByID(t *testing.T) { db := mocks.NewRepository(t) - handler := New(db) + handler := New(db, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver.go b/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver.go index b2cf13ab6d..8f764b3787 100644 --- a/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver.go +++ b/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver.go @@ -2,6 +2,7 @@ package hgreetserver import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/jsonrpc/mjsonrpc" "popstellar/internal/handler/method/greetserver/mgreetserver" @@ -22,12 +23,14 @@ type Peers interface { type Handler struct { conf Config peers Peers + log zerolog.Logger } -func New(conf Config, peers Peers) *Handler { +func New(conf Config, peers Peers, log zerolog.Logger) *Handler { return &Handler{ conf: conf, peers: peers, + log: log.With().Str("module", "greetserver").Logger(), } } diff --git a/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver_test.go b/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver_test.go index 83c6c0e031..80668280ec 100644 --- a/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver_test.go +++ b/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver_test.go @@ -1,7 +1,9 @@ package hgreetserver import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/errors" mocks2 "popstellar/internal/handler/method/greetserver/hgreetserver/mocks" "popstellar/internal/network/socket/mocks" @@ -13,7 +15,7 @@ func Test_handleGreetServer(t *testing.T) { conf := mocks2.NewConfig(t) peers := mocks2.NewPeers(t) - handler := New(conf, peers) + handler := New(conf, peers, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat.go b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat.go index cb09478ec8..a0597b9435 100644 --- a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat.go +++ b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat.go @@ -2,6 +2,7 @@ package hheartbeat import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/jsonrpc/mjsonrpc" "popstellar/internal/handler/method/getmessagesbyid/mgetmessagesbyid" @@ -23,12 +24,14 @@ type Repository interface { type Handler struct { queries Queries db Repository + log zerolog.Logger } -func New(queries Queries, db Repository) *Handler { +func New(queries Queries, db Repository, log zerolog.Logger) *Handler { return &Handler{ queries: queries, db: db, + log: log.With().Str("module", "heartbeat").Logger(), } } diff --git a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go index 48c33b99b7..1edf1ea925 100644 --- a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go +++ b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go @@ -2,9 +2,11 @@ package hheartbeat import ( "encoding/json" + "github.com/rs/zerolog" mock2 "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "golang.org/x/xerrors" + "io" "popstellar/internal/handler/method/getmessagesbyid/mgetmessagesbyid" mocks2 "popstellar/internal/handler/method/heartbeat/hheartbeat/mocks" "popstellar/internal/network/socket/mocks" @@ -16,7 +18,7 @@ func Test_handleHeartbeat(t *testing.T) { queries := mocks2.NewQueries(t) db := mocks2.NewRepository(t) - handler := New(queries, db) + handler := New(queries, db, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/publish/hpublish/publish.go b/be1-go/internal/handler/method/publish/hpublish/publish.go index 5e27f52ca2..7d28cc7601 100644 --- a/be1-go/internal/handler/method/publish/hpublish/publish.go +++ b/be1-go/internal/handler/method/publish/hpublish/publish.go @@ -2,6 +2,7 @@ package hpublish import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/publish/mpublish" @@ -29,13 +30,15 @@ type Handler struct { hub Hub db Repository messageHandler MessageHandler + log zerolog.Logger } -func New(hub Hub, db Repository, messageHandler MessageHandler) *Handler { +func New(hub Hub, db Repository, messageHandler MessageHandler, log zerolog.Logger) *Handler { return &Handler{ hub: hub, db: db, messageHandler: messageHandler, + log: log.With().Str("module", "publish").Logger(), } } diff --git a/be1-go/internal/handler/method/rumor/hrumor/rumor.go b/be1-go/internal/handler/method/rumor/hrumor/rumor.go index 6c66f8d7dd..e93bcd2fe2 100644 --- a/be1-go/internal/handler/method/rumor/hrumor/rumor.go +++ b/be1-go/internal/handler/method/rumor/hrumor/rumor.go @@ -2,6 +2,7 @@ package hrumor import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/rumor/mrumor" @@ -41,15 +42,16 @@ type Handler struct { sockets Sockets db Repository messageHandler MessageHandler + log zerolog.Logger } -func New(queries Queries, sockets Sockets, db Repository, - messageHandler MessageHandler) *Handler { +func New(queries Queries, sockets Sockets, db Repository, messageHandler MessageHandler, log zerolog.Logger) *Handler { return &Handler{ queries: queries, sockets: sockets, db: db, messageHandler: messageHandler, + log: log.With().Str("module", "rumor").Logger(), } } diff --git a/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe.go b/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe.go index a0fba7e144..400b51b43e 100644 --- a/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe.go +++ b/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe.go @@ -2,6 +2,7 @@ package hsubscribe import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/method/subscribe/msubscribe" @@ -14,10 +15,14 @@ type Subscribers interface { type Handler struct { subs Subscribers + log zerolog.Logger } -func New(subs Subscribers) *Handler { - return &Handler{subs: subs} +func New(subs Subscribers, log zerolog.Logger) *Handler { + return &Handler{ + subs: subs, + log: log.With().Str("module", "subscribe").Logger(), + } } func (h *Handler) Handle(socket socket.Socket, msg []byte) (*int, error) { diff --git a/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe_test.go b/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe_test.go index 7c0bdfac1f..9ff78e6968 100644 --- a/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe_test.go +++ b/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe_test.go @@ -1,7 +1,9 @@ package hsubscribe import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/errors" "popstellar/internal/handler/method/subscribe/hsubscribe/mocks" mocks2 "popstellar/internal/network/socket/mocks" @@ -12,7 +14,7 @@ import ( func Test_handleSubscribe(t *testing.T) { subs := mocks.NewSubscribers(t) - handler := New(subs) + handler := New(subs, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe.go b/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe.go index 8490bde241..8a333373e1 100644 --- a/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe.go +++ b/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe.go @@ -2,6 +2,7 @@ package hunsubscribe import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/method/unsubscribe/munsubscribe" @@ -14,10 +15,14 @@ type Subscribers interface { type Handler struct { subs Subscribers + log zerolog.Logger } -func New(subs Subscribers) *Handler { - return &Handler{subs: subs} +func New(subs Subscribers, log zerolog.Logger) *Handler { + return &Handler{ + subs: subs, + log: log.With().Str("module", "unsubscribe").Logger(), + } } func (h *Handler) Handle(socket socket.Socket, msg []byte) (*int, error) { diff --git a/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe_test.go b/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe_test.go index 0eb0af0302..f5e336cbf7 100644 --- a/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe_test.go +++ b/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe_test.go @@ -1,7 +1,9 @@ package hunsubscribe import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/errors" "popstellar/internal/handler/method/unsubscribe/hunsubscribe/mocks" mocks2 "popstellar/internal/network/socket/mocks" @@ -12,7 +14,7 @@ import ( func Test_handleUnsubscribe(t *testing.T) { subs := mocks.NewSubscribers(t) - handler := New(subs) + handler := New(subs, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/query/hquery/query.go b/be1-go/internal/handler/query/hquery/query.go index 00036db265..1f87692b6f 100644 --- a/be1-go/internal/handler/query/hquery/query.go +++ b/be1-go/internal/handler/query/hquery/query.go @@ -2,6 +2,7 @@ package hquery import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/query/mquery" "popstellar/internal/network/socket" @@ -24,11 +25,13 @@ type MethodHandlers struct { type Handler struct { handlers MethodHandlers + log zerolog.Logger } -func New(handlers MethodHandlers) *Handler { +func New(handlers MethodHandlers, log zerolog.Logger) *Handler { return &Handler{ handlers: handlers, + log: log.With().Str("module", "query").Logger(), } } diff --git a/be1-go/internal/handler/query/hquery/query_test.go b/be1-go/internal/handler/query/hquery/query_test.go index 5b71edf3c9..8bccd725db 100644 --- a/be1-go/internal/handler/query/hquery/query_test.go +++ b/be1-go/internal/handler/query/hquery/query_test.go @@ -1,7 +1,9 @@ package hquery import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/handler/query/hquery/mocks" mocks2 "popstellar/internal/network/socket/mocks" "popstellar/internal/test/generator" @@ -29,7 +31,7 @@ func Test_handleQuery(t *testing.T) { Rumor: methodHandler, } - handler := New(methodHandlers) + handler := New(methodHandlers, zerolog.New(io.Discard)) args := make([]input, 0) diff --git a/be1-go/internal/hub/hub.go b/be1-go/internal/hub/hub.go index 600800292f..8fb5d865c9 100644 --- a/be1-go/internal/hub/hub.go +++ b/be1-go/internal/hub/hub.go @@ -157,44 +157,44 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st // Create the message data handlers dataHandlers := hmessage.DataHandlers{ - Root: hroot.New(conf, &db, subs, peers, schemaValidator), - Lao: hlao.New(conf, subs, &db, schemaValidator), - Election: helection.New(conf, subs, &db, schemaValidator), - Chirp: hchirp.New(conf, subs, &db, schemaValidator), - Reaction: hreaction.New(subs, &db, schemaValidator), - Coin: hcoin.New(subs, &db, schemaValidator), - Federation: hfederation.New(hubParams, subs, &db, schemaValidator), + Root: hroot.New(conf, &db, subs, peers, schemaValidator, log), + Lao: hlao.New(conf, subs, &db, schemaValidator, log), + Election: helection.New(conf, subs, &db, schemaValidator, log), + Chirp: hchirp.New(conf, subs, &db, schemaValidator, log), + Reaction: hreaction.New(subs, &db, schemaValidator, log), + Coin: hcoin.New(subs, &db, schemaValidator, log), + Federation: hfederation.New(hubParams, subs, &db, schemaValidator, log), } // Create the message handler - msgHandler := hmessage.New(&db, dataHandlers) + msgHandler := hmessage.New(&db, dataHandlers, log) // Create the greetserver handler - greetserverHandler := hgreetserver.New(conf, peers) + greetserverHandler := hgreetserver.New(conf, peers, log) // Create the rumor handler - rumorHandler := hrumor.New(queries, sockets, &db, msgHandler) + rumorHandler := hrumor.New(queries, sockets, &db, msgHandler, log) // Create the query handler qHandler := hquery.New(hquery.MethodHandlers{ - Catchup: hcatchup.New(&db), - GetMessagesbyid: hgetmessagesbyid.New(&db), + Catchup: hcatchup.New(&db, log), + GetMessagesbyid: hgetmessagesbyid.New(&db, log), Greetserver: greetserverHandler, - Heartbeat: hheartbeat.New(queries, &db), - Publish: hpublish.New(hubParams, &db, msgHandler), - Subscribe: hsubscribe.New(subs), - Unsubscribe: hunsubscribe.New(subs), + Heartbeat: hheartbeat.New(queries, &db, log), + Publish: hpublish.New(hubParams, &db, msgHandler, log), + Subscribe: hsubscribe.New(subs, log), + Unsubscribe: hunsubscribe.New(subs, log), Rumor: rumorHandler, - }) + }, log) // Create the answer handler aHandler := hanswer.New(queries, hanswer.Handlers{ MessageHandler: msgHandler, RumorSender: rumorHandler, - }) + }, log) // Create the json rpc handler - jsonRpcHandler := hjsonrpc.New(schemaValidator, qHandler, aHandler) + jsonRpcHandler := hjsonrpc.New(schemaValidator, qHandler, aHandler, log) // Create the hub hub := &Hub{ diff --git a/be1-go/internal/network/socket/socket_impl.go b/be1-go/internal/network/socket/socket_impl.go index 6c66280b3b..27ac3b02fd 100644 --- a/be1-go/internal/network/socket/socket_impl.go +++ b/be1-go/internal/network/socket/socket_impl.go @@ -272,9 +272,14 @@ func newBaseSocket(socketType SocketType, receiver chan<- IncomingMessage, done chan struct{}, log zerolog.Logger, ) *baseSocket { id := xid.New().String() - log = log.With().Dict("socket", zerolog.Dict(). - Str("ID", id). - Str("IP", conn.RemoteAddr().String())).Logger() + + if conn != nil { + log = log.With().Dict("socket", zerolog.Dict(). + Str("ID", id). + Str("IP", conn.RemoteAddr().String())).Logger() + } else { + log = log.With().Str("socketID", id).Logger() + } return &baseSocket{ id: id, diff --git a/be1-go/internal/network/socket/socket_impl_test.go b/be1-go/internal/network/socket/socket_impl_test.go index 4d1a1213a5..68d3dc4c14 100644 --- a/be1-go/internal/network/socket/socket_impl_test.go +++ b/be1-go/internal/network/socket/socket_impl_test.go @@ -2,7 +2,6 @@ package socket import ( "encoding/json" - "github.com/gorilla/websocket" "github.com/rs/zerolog" "github.com/stretchr/testify/require" "os" @@ -88,7 +87,7 @@ var socket = *newBaseSocket( ServerSocketType, make(chan IncomingMessage), make(chan string), - &websocket.Conn{}, + nil, &sync.WaitGroup{}, make(chan struct{}), zerolog.New(zerolog.ConsoleWriter{Out: os.Stdout}).With().Timestamp().Logger(), From dbedb61f1b098e806dcaef7ebe6d50c0c9784a5e Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 14:20:28 +0200 Subject: [PATCH 04/10] remove log from old backend --- be1-go/internal/old/hub/standard_hub/message_handling.go | 4 +--- .../old/oldchannel/authentication/authentication_test.go | 6 ++---- be1-go/internal/old/oldchannel/lao/lao.go | 6 ++---- 3 files changed, 5 insertions(+), 11 deletions(-) diff --git a/be1-go/internal/old/hub/standard_hub/message_handling.go b/be1-go/internal/old/hub/standard_hub/message_handling.go index a6d4df54e2..ee7a2496f2 100644 --- a/be1-go/internal/old/hub/standard_hub/message_handling.go +++ b/be1-go/internal/old/hub/standard_hub/message_handling.go @@ -22,8 +22,6 @@ import ( "popstellar/internal/old/hub/standard_hub/hub_state" "popstellar/internal/validation" - "github.com/rs/zerolog/log" - "go.dedis.ch/kyber/v3/sign/schnorr" "golang.org/x/exp/slices" @@ -523,7 +521,7 @@ func (h *Hub) handleReceivedMessage(socket socket.Socket, messageData mmessage.M signature := messageData.Signature messageID := messageData.MessageID data := messageData.Data - log.Info().Msgf("Received message on %s", targetChannel) + //log.Info().Msgf("Received message on %s", targetChannel) expectedMessageID := channel.Hash(data, signature) if expectedMessageID != messageID { diff --git a/be1-go/internal/old/oldchannel/authentication/authentication_test.go b/be1-go/internal/old/oldchannel/authentication/authentication_test.go index 51f9253972..94181f0060 100644 --- a/be1-go/internal/old/oldchannel/authentication/authentication_test.go +++ b/be1-go/internal/old/oldchannel/authentication/authentication_test.go @@ -7,7 +7,6 @@ import ( "github.com/gorilla/websocket" "github.com/rs/xid" "github.com/rs/zerolog" - "github.com/rs/zerolog/log" "github.com/stretchr/testify/require" "go.dedis.ch/kyber/v3" "go.dedis.ch/kyber/v3/sign/schnorr" @@ -25,7 +24,6 @@ import ( "popstellar/internal/handler/method/broadcast/mbroadcast" "popstellar/internal/handler/method/greetserver/mgreetserver" method2 "popstellar/internal/handler/method/publish/mpublish" - "popstellar/internal/logger" "popstellar/internal/network/socket" "popstellar/internal/old/oldchannel" "popstellar/internal/validation" @@ -54,7 +52,7 @@ func TestJWTToken(t *testing.T) { idToken, err := createJWTString(webAddr, ppid, cID, nonce, sk) require.NoError(t, err) - log.Info().Msg(idToken) + //log.Info().Msg(idToken) // verifying the token token, err := jwt.Parse(idToken, func(jwtToken *jwt.Token) (interface{}, error) { _, ok := jwtToken.Method.(*jwt.SigningMethodRSA) @@ -106,7 +104,7 @@ func Test_Authenticate_User(t *testing.T) { require.NoError(t, err) name := "3hfd5xSty1VShCdcfLUDsgNF_EnMSRiFk74xvH5LRjM=/authenticate" // Create the oldchannel - authCha := NewChannel("3hfd5xSty1VShCdcfLUDsgNF_EnMSRiFk74xvH5LRjM=/authenticate", fakeHub, logger.Logger, secPathTest, pubPathtest) + authCha := NewChannel("3hfd5xSty1VShCdcfLUDsgNF_EnMSRiFk74xvH5LRjM=/authenticate", fakeHub, zerolog.New(io.Discard), secPathTest, pubPathtest) fakeHub.RegisterNewChannel(name, authCha) _, found := fakeHub.channelByID[name] diff --git a/be1-go/internal/old/oldchannel/lao/lao.go b/be1-go/internal/old/oldchannel/lao/lao.go index d978472388..1d8dc8aad3 100644 --- a/be1-go/internal/old/oldchannel/lao/lao.go +++ b/be1-go/internal/old/oldchannel/lao/lao.go @@ -35,8 +35,6 @@ import ( "go.dedis.ch/kyber/v3" - "github.com/rs/zerolog/log" - "github.com/rs/zerolog" "go.dedis.ch/kyber/v3/sign/schnorr" "golang.org/x/xerrors" @@ -610,7 +608,7 @@ func createGeneralChirpingChannel(laoID string, hub oldchannel.HubFunctionalitie generalChirpingChannel := generalChirping.NewChannel(generalChannelPath, hub, popstellar.Logger) hub.NotifyNewChannel(generalChannelPath, generalChirpingChannel, socket) - log.Info().Msgf("storing new oldchannel '%s' ", generalChannelPath) + //log.Info().Msgf("storing new oldchannel '%s' ", generalChannelPath) return generalChirpingChannel } @@ -620,7 +618,7 @@ func (c *Channel) createChirpingChannel(publicKey string, socket socket.Socket) cha := chirp.NewChannel(chirpingChannelPath, publicKey, c.hub, c.general, popstellar.Logger) c.hub.NotifyNewChannel(chirpingChannelPath, cha, socket) - log.Info().Msgf("storing new chirp oldchannel (%s) for: '%s'", c.channelID, publicKey) + //log.Info().Msgf("storing new chirp oldchannel (%s) for: '%s'", c.channelID, publicKey) } // createAuthChannel creates an authentication oldchannel associated to the laoID, handling PopCHA requests From b9b57616aa5f1446a4caaa9c914fcbeb6cbcb956 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 14:25:33 +0200 Subject: [PATCH 05/10] add log to sqlite --- be1-go/internal/database/sqlite/sqlite_init.go | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/be1-go/internal/database/sqlite/sqlite_init.go b/be1-go/internal/database/sqlite/sqlite_init.go index 16011ee74e..cbe2aeabc0 100644 --- a/be1-go/internal/database/sqlite/sqlite_init.go +++ b/be1-go/internal/database/sqlite/sqlite_init.go @@ -3,6 +3,7 @@ package sqlite import ( "database/sql" "encoding/base64" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" poperrors "popstellar/internal/errors" "popstellar/internal/handler/channel" @@ -14,6 +15,7 @@ var dbLock sync.RWMutex // SQLite is a wrapper around the SQLite database. type SQLite struct { database *sql.DB + log zerolog.Logger } //====================================================================================================================== @@ -21,7 +23,7 @@ type SQLite struct { //====================================================================================================================== // NewSQLite returns a new SQLite instance. -func NewSQLite(path string, foreignKeyOn bool) (SQLite, error) { +func NewSQLite(path string, foreignKeyOn bool, log zerolog.Logger) (SQLite, error) { dbLock.Lock() defer dbLock.Unlock() @@ -99,7 +101,10 @@ func NewSQLite(path string, foreignKeyOn bool) (SQLite, error) { return SQLite{}, poperrors.NewDatabaseTransactionCommitErrorMsg("%v", err) } - return SQLite{database: db}, nil + return SQLite{ + database: db, + log: log.With().Str("module", "sqlite").Logger(), + }, nil } func initRumorTables(tx *sql.Tx) error { From ec738676ba907f48bf3c57928d2ec34d7da35544 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 14:26:03 +0200 Subject: [PATCH 06/10] fix hub --- be1-go/internal/hub/hub.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/be1-go/internal/hub/hub.go b/be1-go/internal/hub/hub.go index 8fb5d865c9..15b5683524 100644 --- a/be1-go/internal/hub/hub.go +++ b/be1-go/internal/hub/hub.go @@ -104,7 +104,7 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st sockets := state.NewSockets(log) // Initialize the database - db, err := sqlite.NewSQLite(dbPath, true) + db, err := sqlite.NewSQLite(dbPath, true, log) if err != nil { return nil, err } From 0ba7ee16e6dbf00126d53790ddb87ede71e4acf1 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 14:27:11 +0200 Subject: [PATCH 07/10] fix sqlite test --- be1-go/internal/database/sqlite/sqlite_test.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/be1-go/internal/database/sqlite/sqlite_test.go b/be1-go/internal/database/sqlite/sqlite_test.go index 26e88099e0..a56dd6a1a9 100644 --- a/be1-go/internal/database/sqlite/sqlite_test.go +++ b/be1-go/internal/database/sqlite/sqlite_test.go @@ -5,7 +5,9 @@ import ( "encoding/base64" "encoding/json" "fmt" + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "os" "path/filepath" "popstellar/internal/crypto" @@ -82,7 +84,7 @@ func newFakeSQLite(t *testing.T) (SQLite, string, error) { require.NoError(t, err) fn := filepath.Join(dir, "test.DB") - lite, err := NewSQLite(fn, false) + lite, err := NewSQLite(fn, false, zerolog.New(io.Discard)) require.NoError(t, err) return lite, dir, nil From e9209933e102c3b7eae156ff2b54bfe48edabb16 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 16:13:31 +0200 Subject: [PATCH 08/10] better error logging inside logic --- be1-go/internal/database/sqlite/query.go | 4 +-- be1-go/internal/errors/errors.go | 32 ++++++++++++++++++++++-- be1-go/internal/hub/hub.go | 27 ++++++++++++++------ be1-go/internal/state/config.go | 2 +- be1-go/internal/state/hub_params.go | 2 +- be1-go/internal/state/peers.go | 2 +- be1-go/internal/state/queries.go | 2 +- be1-go/internal/state/sockets.go | 2 +- be1-go/internal/state/subscribers.go | 2 +- 9 files changed, 58 insertions(+), 17 deletions(-) diff --git a/be1-go/internal/database/sqlite/query.go b/be1-go/internal/database/sqlite/query.go index 6c0de89bd0..f488fb42b0 100644 --- a/be1-go/internal/database/sqlite/query.go +++ b/be1-go/internal/database/sqlite/query.go @@ -149,7 +149,7 @@ func (s *SQLite) CheckRumor(senderID string, rumorID int) (bool, error) { if rumorID == 0 { err := s.database.QueryRow(selectAnyRumor, senderID).Scan(&id) if err != nil && !errors.Is(err, sql.ErrNoRows) { - return false, err + return false, poperrors.NewDatabaseSelectErrorMsg(err.Error()) } else if errors.Is(err, sql.ErrNoRows) { return true, nil } @@ -158,7 +158,7 @@ func (s *SQLite) CheckRumor(senderID string, rumorID int) (bool, error) { err := s.database.QueryRow(selectLastRumor, senderID).Scan(&id) if err != nil && !errors.Is(err, sql.ErrNoRows) { - return false, err + return false, poperrors.NewDatabaseSelectErrorMsg(err.Error()) } else if errors.Is(err, sql.ErrNoRows) { return false, nil } diff --git a/be1-go/internal/errors/errors.go b/be1-go/internal/errors/errors.go index 53512870b5..79b45359f7 100644 --- a/be1-go/internal/errors/errors.go +++ b/be1-go/internal/errors/errors.go @@ -1,7 +1,9 @@ package errors import ( + "encoding/json" "fmt" + "path/filepath" "runtime" ) @@ -55,7 +57,7 @@ func (p *PopError) Error() string { func NewPopError(code int, format string, a ...interface{}) *PopError { var pcs [depthStack]uintptr - n := runtime.Callers(2, pcs[:]) + n := runtime.Callers(3, pcs[:]) stack := pcs[0:n] return &PopError{ @@ -75,14 +77,40 @@ func (p *PopError) StackTraceString() string { for { frame, ok := frames.Next() - stackTrace += fmt.Sprintf("%s\n\t%s:%d\n", frame.Function, frame.File, frame.Line) if !ok { break } + stackTrace += fmt.Sprintf("%s\n\t%s:%d\n", filepath.Base(frame.Function), filepath.Base(frame.File), frame.Line) } + return stackTrace } +type Frame struct { + Function string `json:"function"` + File string `json:"file"` + Line int `json:"line"` +} + +func (p *PopError) GetStackTraceJSON() ([]byte, error) { + frames := runtime.CallersFrames(p.stackTrace) + var stackTraceArray []Frame + + for { + frame, ok := frames.Next() + if !ok { + break + } + stackTraceArray = append(stackTraceArray, Frame{ + Function: filepath.Base(frame.Function), + File: filepath.Base(frame.File), + Line: frame.Line, + }) + } + + return json.Marshal(stackTraceArray) +} + // NewInvalidActionError returns an error with the code -1 for an invalid action func NewInvalidActionError(format string, a ...interface{}) error { return NewPopError(InvalidActionErrorCode, InvalidActionErrorMsg+format, a...) diff --git a/be1-go/internal/hub/hub.go b/be1-go/internal/hub/hub.go index 15b5683524..de378158f8 100644 --- a/be1-go/internal/hub/hub.go +++ b/be1-go/internal/hub/hub.go @@ -2,11 +2,12 @@ package hub import ( "encoding/json" + "errors" "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/database/sqlite" - "popstellar/internal/errors" + poperrors "popstellar/internal/errors" "popstellar/internal/handler/answer/hanswer" "popstellar/internal/handler/channel/chirp/hchirp" "popstellar/internal/handler/channel/coin/hcoin" @@ -25,7 +26,7 @@ import ( "popstellar/internal/handler/method/heartbeat/mheartbeat" "popstellar/internal/handler/method/publish/hpublish" "popstellar/internal/handler/method/rumor/hrumor" - method2 "popstellar/internal/handler/method/rumor/mrumor" + "popstellar/internal/handler/method/rumor/mrumor" "popstellar/internal/handler/method/subscribe/hsubscribe" "popstellar/internal/handler/method/unsubscribe/hunsubscribe" "popstellar/internal/handler/query/hquery" @@ -55,7 +56,7 @@ type Sockets interface { type Repository interface { // GetAndIncrementMyRumor return false if the last rumor is empty otherwise returns the new rumor to send and create the next rumor - GetAndIncrementMyRumor() (bool, method2.Rumor, error) + GetAndIncrementMyRumor() (bool, mrumor.Rumor, error) GetParamsHeartbeat() (map[string][]string, error) } @@ -69,7 +70,7 @@ type GreetServerSender interface { } type RumorSender interface { - SendRumor(socket socket.Socket, rumor method2.Rumor) + SendRumor(socket socket.Socket, rumor mrumor.Rumor) } type Hub struct { @@ -209,7 +210,7 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st jsonRpcHandler: jsonRpcHandler, greetserverSender: greetserverHandler, rumorSender: rumorHandler, - log: log.With().Str("role", "hub").Logger(), + log: log.With().Str("module", "hub").Logger(), } return hub, nil @@ -256,7 +257,19 @@ func (h *Hub) runMessageReceiver() { h.log.Debug().Msg("start handling a message") err := h.jsonRpcHandler.Handle(incomingMessage.Socket, incomingMessage.Message) if err != nil { - h.log.Error().Err(err) + popError := &poperrors.PopError{} + if !errors.As(err, &popError) { + popError = poperrors.NewPopError(-6, err.Error()) + } + + stack, err := popError.GetStackTraceJSON() + if err != nil { + h.log.Error().Err(err).Msg("failed to get stacktrace") + h.log.Error().Err(popError).Msg("") + } else { + h.log.Error().Err(popError).RawJSON("stacktrace", stack).Msg("") + } + } else { h.log.Debug().Msg("successfully handled a message") } @@ -348,7 +361,7 @@ func (h *Hub) sendHeartbeat() error { buf, err := json.Marshal(heartbeatMessage) if err != nil { - return errors.NewJsonMarshalError(err.Error()) + return poperrors.NewJsonMarshalError(err.Error()) } h.sockets.SendToAll(buf) diff --git a/be1-go/internal/state/config.go b/be1-go/internal/state/config.go index aad3eeff69..213d8039f5 100644 --- a/be1-go/internal/state/config.go +++ b/be1-go/internal/state/config.go @@ -26,7 +26,7 @@ func CreateConfig(ownerPubKey, serverPubKey kyber.Point, serverSecretKey kyber.S serverSecretKey: serverSecretKey, clientServerAddress: clientServerAddress, serverServerAddress: serverServerAddress, - log: log.With().Str("role", "config").Logger(), + log: log.With().Str("module", "config").Logger(), } } diff --git a/be1-go/internal/state/hub_params.go b/be1-go/internal/state/hub_params.go index a0f3bd90bf..bce4f027ce 100644 --- a/be1-go/internal/state/hub_params.go +++ b/be1-go/internal/state/hub_params.go @@ -21,7 +21,7 @@ func NewHubParams(log zerolog.Logger) *HubParams { stop: make(chan struct{}), closedSockets: make(chan string), resetRumorSender: make(chan struct{}), - log: log.With().Str("role", "hub_params").Logger(), + log: log.With().Str("module", "hub_params").Logger(), } } diff --git a/be1-go/internal/state/peers.go b/be1-go/internal/state/peers.go index e2f7444679..807dbc7530 100644 --- a/be1-go/internal/state/peers.go +++ b/be1-go/internal/state/peers.go @@ -25,7 +25,7 @@ func NewPeers(log zerolog.Logger) *Peers { return &Peers{ peersInfo: make(map[string]mgreetserver.GreetServerParams), peersGreeted: make(map[string]struct{}), - log: log.With().Str("role", "peers").Logger(), + log: log.With().Str("module", "peers").Logger(), } } diff --git a/be1-go/internal/state/queries.go b/be1-go/internal/state/queries.go index 343a511188..6cf6d16934 100644 --- a/be1-go/internal/state/queries.go +++ b/be1-go/internal/state/queries.go @@ -31,7 +31,7 @@ func NewQueries(log zerolog.Logger) *Queries { state: make(map[int]bool), getMessagesByIdQueries: make(map[int]mgetmessagesbyid.GetMessagesById), getRumorQueries: make(map[int]mrumor.Rumor), - log: log.With().Str("role", "queries").Logger(), + log: log.With().Str("module", "queries").Logger(), } } diff --git a/be1-go/internal/state/sockets.go b/be1-go/internal/state/sockets.go index 607e092b13..5dc5f2bd32 100644 --- a/be1-go/internal/state/sockets.go +++ b/be1-go/internal/state/sockets.go @@ -14,7 +14,7 @@ func NewSockets(log zerolog.Logger) *Sockets { rState: make(map[string]rumorState), socketIDs: make([]string, 0), store: make(map[string]socket.Socket), - log: log.With().Str("role", "sockets").Logger(), + log: log.With().Str("module", "sockets").Logger(), } } diff --git a/be1-go/internal/state/subscribers.go b/be1-go/internal/state/subscribers.go index f5cb97e36e..a016edcb26 100644 --- a/be1-go/internal/state/subscribers.go +++ b/be1-go/internal/state/subscribers.go @@ -21,7 +21,7 @@ type Subscribers struct { func NewSubscribers(log zerolog.Logger) *Subscribers { return &Subscribers{ list: make(map[string]map[string]socket.Socket), - log: log.With().Str("role", "subscribers").Logger(), + log: log.With().Str("module", "subscribers").Logger(), } } From d67f77c63a16910b8850cff47ba82c4e38a149b4 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 16:52:01 +0200 Subject: [PATCH 09/10] fix import names --- be1-go/cli/cli_test.go | 5 ++--- .../handler/method/heartbeat/hheartbeat/heartbeat_test.go | 4 ++-- be1-go/internal/state/peers.go | 5 ++--- 3 files changed, 6 insertions(+), 8 deletions(-) diff --git a/be1-go/cli/cli_test.go b/be1-go/cli/cli_test.go index d0554248ca..831aee2b53 100644 --- a/be1-go/cli/cli_test.go +++ b/be1-go/cli/cli_test.go @@ -3,6 +3,8 @@ package main import ( "encoding/json" "github.com/fsnotify/fsnotify" + "github.com/rs/zerolog" + "github.com/stretchr/testify/require" "golang.org/x/xerrors" "io" "os" @@ -14,9 +16,6 @@ import ( "sync" "testing" "time" - - "github.com/rs/zerolog" - "github.com/stretchr/testify/require" ) const ( diff --git a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go index 1edf1ea925..2423430d6c 100644 --- a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go +++ b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go @@ -3,7 +3,7 @@ package hheartbeat import ( "encoding/json" "github.com/rs/zerolog" - mock2 "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "golang.org/x/xerrors" "io" @@ -63,7 +63,7 @@ func Test_handleHeartbeat(t *testing.T) { db.On("GetParamsForGetMessageByID", heartbeatMsgIDs1).Return(expected1, nil) queries.On("GetNextID").Return(1) - queries.On("AddQuery", 1, mock2.AnythingOfType("mgetmessagesbyid.GetMessagesById")) + queries.On("AddQuery", 1, mock.AnythingOfType("mgetmessagesbyid.GetMessagesById")) args = append(args, input{ name: "Test 1", diff --git a/be1-go/internal/state/peers.go b/be1-go/internal/state/peers.go index 807dbc7530..31cb1faa88 100644 --- a/be1-go/internal/state/peers.go +++ b/be1-go/internal/state/peers.go @@ -2,12 +2,11 @@ package state import ( "github.com/rs/zerolog" + "golang.org/x/exp/maps" + "golang.org/x/exp/slices" "popstellar/internal/errors" "popstellar/internal/handler/method/greetserver/mgreetserver" "sync" - - "golang.org/x/exp/maps" - "golang.org/x/exp/slices" ) // Peers stores the peers' information From c1973186abbb2365a60ddc4e354b33ad7245bfc3 Mon Sep 17 00:00:00 2001 From: stuart Date: Wed, 12 Jun 2024 21:05:59 +0200 Subject: [PATCH 10/10] use constant --- be1-go/internal/hub/hub.go | 2 +- be1-go/internal/network/socket/socket_impl.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/be1-go/internal/hub/hub.go b/be1-go/internal/hub/hub.go index de378158f8..56a8f13b82 100644 --- a/be1-go/internal/hub/hub.go +++ b/be1-go/internal/hub/hub.go @@ -259,7 +259,7 @@ func (h *Hub) runMessageReceiver() { if err != nil { popError := &poperrors.PopError{} if !errors.As(err, &popError) { - popError = poperrors.NewPopError(-6, err.Error()) + popError = poperrors.NewPopError(poperrors.InternalServerErrorCode, err.Error()) } stack, err := popError.GetStackTraceJSON() diff --git a/be1-go/internal/network/socket/socket_impl.go b/be1-go/internal/network/socket/socket_impl.go index 27ac3b02fd..def8acd363 100644 --- a/be1-go/internal/network/socket/socket_impl.go +++ b/be1-go/internal/network/socket/socket_impl.go @@ -190,7 +190,7 @@ func (s *baseSocket) SendPopError(id *int, err error) { popError := &poperror.PopError{} if !errors.As(err, &popError) { - popError = poperror.NewPopError(-6, err.Error()) + popError = poperror.NewPopError(poperror.InternalServerErrorCode, err.Error()) } description := popError.Error() + "\n" + popError.StackTraceString()