Use strings.ReplaceAll method

[rbdr/mobius] / hotline / client.go

diff --git a/hotline/client.go b/hotline/client.go
index 6abe62322bfd3c95d6fc99f0b5137190a682edb5..f3e83c801b2132b6f84d8b1ba3d08005139cd953 100644 (file)
--- a/hotline/client.go
+++ b/hotline/client.go
@@ -82,18 +82,24 @@ type Client struct {
 
        Pref *ClientPrefs
 
 
        Pref *ClientPrefs
 

-       Handlers map[uint16]ClientTHandler
+       Handlers map[uint16]ClientHandler

 
        UI *UI
 
        Inbox chan *Transaction
 }
 
 
        UI *UI
 
        Inbox chan *Transaction
 }
 

+type ClientHandler func(*Client, *Transaction) ([]Transaction, error)
+
+func (c *Client) HandleFunc(transactionID uint16, handler ClientHandler) {
+       c.Handlers[transactionID] = handler
+}
+

 func NewClient(username string, logger *zap.SugaredLogger) *Client {
        c := &Client{
                Logger:      logger,
                activeTasks: make(map[uint32]*Transaction),
 func NewClient(username string, logger *zap.SugaredLogger) *Client {
        c := &Client{
                Logger:      logger,
                activeTasks: make(map[uint32]*Transaction),

-               Handlers:    make(map[uint16]ClientTHandler),
+               Handlers:    make(map[uint16]ClientHandler),

        }
        c.Pref = &ClientPrefs{Username: username}
 
        }
        c.Pref = &ClientPrefs{Username: username}
 


@@ -163,53 +169,19 @@ func (mh *mockClientHandler) Handle(cc *Client, t *Transaction) ([]Transaction,
        return args.Get(0).([]Transaction), args.Error(1)
 }
 
        return args.Get(0).([]Transaction), args.Error(1)
 }
 

-var clientHandlers = map[uint16]ClientTHandler{
-       // Server initiated
-       TranChatMsg: ClientTransaction{
-               Name:    "TranChatMsg",
-               Handler: handleClientChatMsg,
-       },
-       TranLogin: ClientTransaction{
-               Name:    "TranLogin",
-               Handler: handleClientTranLogin,
-       },
-       TranShowAgreement: ClientTransaction{
-               Name:    "TranShowAgreement",
-               Handler: handleClientTranShowAgreement,
-       },
-       TranUserAccess: ClientTransaction{
-               Name:    "TranUserAccess",
-               Handler: handleClientTranUserAccess,
-       },
-       TranGetUserNameList: ClientTransaction{
-               Name:    "TranGetUserNameList",
-               Handler: handleClientGetUserNameList,
-       },
-       TranNotifyChangeUser: ClientTransaction{
-               Name:    "TranNotifyChangeUser",
-               Handler: handleNotifyChangeUser,
-       },
-       TranNotifyDeleteUser: ClientTransaction{
-               Name:    "TranNotifyDeleteUser",
-               Handler: handleNotifyDeleteUser,
-       },
-       TranGetMsgs: ClientTransaction{
-               Name:    "TranNotifyDeleteUser",
-               Handler: handleGetMsgs,
-       },
-       TranGetFileNameList: ClientTransaction{
-               Name:    "TranGetFileNameList",
-               Handler: handleGetFileNameList,
-       },
-       TranServerMsg: ClientTransaction{
-               Name:    "TranServerMsg",
-               Handler: handleTranServerMsg,
-       },
-       TranKeepAlive: ClientTransaction{
-               Name: "TranKeepAlive",
-               Handler: func(client *Client, transaction *Transaction) (t []Transaction, err error) {
-                       return t, err
-               },
+var clientHandlers = map[uint16]ClientHandler{
+       TranChatMsg:          handleClientChatMsg,
+       TranLogin:            handleClientTranLogin,
+       TranShowAgreement:    handleClientTranShowAgreement,
+       TranUserAccess:       handleClientTranUserAccess,
+       TranGetUserNameList:  handleClientGetUserNameList,
+       TranNotifyChangeUser: handleNotifyChangeUser,
+       TranNotifyDeleteUser: handleNotifyDeleteUser,
+       TranGetMsgs:          handleGetMsgs,
+       TranGetFileNameList:  handleGetFileNameList,
+       TranServerMsg:        handleTranServerMsg,
+       TranKeepAlive: func(client *Client, transaction *Transaction) (t []Transaction, err error) {
+               return t, err

        },
 }
 
        },
 }
 


@@ -345,7 +317,6 @@ func handleGetFileNameList(c *Client, t *Transaction) (res []Transaction, err er
                        node.SetReference(&fn)
                        root.AddChild(node)
                }
                        node.SetReference(&fn)
                        root.AddChild(node)
                }

-

        }
 
        centerFlex := tview.NewFlex().
        }
 
        centerFlex := tview.NewFlex().


@@ -571,11 +542,13 @@ func (c *Client) Connect(address, login, passwd string) (err error) {
        return nil
 }
 
        return nil
 }
 

+const keepaliveInterval = 300 * time.Second
+

 func (c *Client) keepalive() error {
        for {
 func (c *Client) keepalive() error {
        for {

-               time.Sleep(300 * time.Second)
+               time.Sleep(keepaliveInterval)

                _ = c.Send(*NewTransaction(TranKeepAlive, nil))
                _ = c.Send(*NewTransaction(TranKeepAlive, nil))

-               c.Logger.Infow("Sent keepalive ping")
+               c.Logger.Debugw("Sent keepalive ping")

        }
 }
 
        }
 }
 


@@ -628,21 +601,18 @@ func (c *Client) LogIn(login string, password string) error {
 
 func (c *Client) Send(t Transaction) error {
        requestNum := binary.BigEndian.Uint16(t.Type)
 
 func (c *Client) Send(t Transaction) error {
        requestNum := binary.BigEndian.Uint16(t.Type)

-       tID := binary.BigEndian.Uint32(t.ID)
-
-       // handler := TransactionHandlers[requestNum]

 
        // if transaction is NOT reply, add it to the list to transactions we're expecting a response for
        if t.IsReply == 0 {
 
        // if transaction is NOT reply, add it to the list to transactions we're expecting a response for
        if t.IsReply == 0 {

-               c.activeTasks[tID] = &t
+               c.activeTasks[binary.BigEndian.Uint32(t.ID)] = &t

        }
 
        }
 

-       var n int
-       var err error

        b, err := t.MarshalBinary()
        if err != nil {
                return err
        }
        b, err := t.MarshalBinary()
        if err != nil {
                return err
        }

+
+       var n int

        if n, err = c.Connection.Write(b); err != nil {
                return err
        }
        if n, err = c.Connection.Write(b); err != nil {
                return err
        }


@@ -662,18 +632,17 @@ func (c *Client) HandleTransaction(t *Transaction) error {
                t.Type = origT.Type
        }
 
                t.Type = origT.Type
        }
 

-       requestNum := binary.BigEndian.Uint16(t.Type)
-       c.Logger.Debugw("Received Transaction", "RequestType", requestNum)
-
-       if handler, ok := c.Handlers[requestNum]; ok {
-               outT, _ := handler.Handle(c, t)
+       if handler, ok := c.Handlers[binary.BigEndian.Uint16(t.Type)]; ok {
+               outT, _ := handler(c, t)

                for _, t := range outT {
                for _, t := range outT {

-                       c.Send(t)
+                       if err := c.Send(t); err != nil {
+                               return err
+                       }

                }
        } else {
                c.Logger.Debugw(
                        "Unimplemented transaction type received",
                }
        } else {
                c.Logger.Debugw(
                        "Unimplemented transaction type received",

-                       "RequestID", requestNum,
+                       "RequestID", t.Type,

                        "TransactionID", t.ID,
                )
        }
                        "TransactionID", t.ID,
                )
        }