Changeset 387 in code for trunk

Timestamp:

Aug 11, 2020, 1:58:50 PM (5 years ago)

Author:

contact

Message:

Extract history loading into functions

These will get re-used for sending history to clients that don't support
the chathistory extension.

Location:

trunk

Files:

• downstream.go (modified) (2 diffs)
• logger.go (modified) (2 diffs)

trunk/downstream.go

@@ -1599 +1599 @@
                 }
 
-                batchRef := "history"
-                maxTries := 100
+                var history []*irc.Message
                 switch subcommand {
                 case "BEFORE":
-                        dc.SendMessage(&irc.Message{
-                                Prefix:  dc.srv.prefix(),
-                                Command: "BATCH",
-                                Params:  []string{"+" + batchRef, "chathistory", target},
-                        })
-
-                        history := make([]*irc.Message, limit)
-                        remaining := limit
-
-                        tries := 0
-                        for remaining > 0 && tries < maxTries {
-                                buf, err := parseMessagesBefore(uc.network, entity, timestamp, remaining)
-                                if err != nil {
-                                        dc.logger.Printf("failed parsing log messages for chathistory: %v", err)
-                                        return newChatHistoryError(subcommand, target)
-                                }
-                                if len(buf) == 0 {
-                                        tries++
-                                } else {
-                                        tries = 0
-                                }
-                                copy(history[remaining-len(buf):], buf)
-                                remaining -= len(buf)
-                                year, month, day := timestamp.Date()
-                                timestamp = time.Date(year, month, day, 0, 0, 0, 0, timestamp.Location()).Add(-1)
-                        }
-
-                        for _, msg := range history[remaining:] {
-                                msg.Tags["batch"] = irc.TagValue(batchRef)
-                                dc.SendMessage(dc.marshalMessage(msg, uc.network))
-                        }
-
-                        dc.SendMessage(&irc.Message{
-                                Prefix:  dc.srv.prefix(),
-                                Command: "BATCH",
-                                Params:  []string{"-" + batchRef},
-                        })
+                        history, err = loadHistoryBeforeTime(uc.network, entity, timestamp, limit)
                 case "AFTER":
-                        dc.SendMessage(&irc.Message{
-                                Prefix:  dc.srv.prefix(),
-                                Command: "BATCH",
-                                Params:  []string{"+" + batchRef, "chathistory", target},
-                        })
-
-                        remaining := limit
-                        tries := 0
-                        now := time.Now()
-                        for remaining > 0 && tries < maxTries && timestamp.Before(now) {
-                                buf, err := parseMessagesAfter(uc.network, entity, timestamp, remaining)
-                                if err != nil {
-                                        dc.logger.Printf("failed parsing log messages for chathistory: %v", err)
-                                        return newChatHistoryError(subcommand, target)
-                                }
-                                if len(buf) == 0 {
-                                        tries++
-                                } else {
-                                        tries = 0
-                                }
-                                for _, msg := range buf {
-                                        msg.Tags["batch"] = irc.TagValue(batchRef)
-                                        dc.SendMessage(dc.marshalMessage(msg, uc.network))
-                                }
-                                remaining -= len(buf)
-                                year, month, day := timestamp.Date()
-                                timestamp = time.Date(year, month, day+1, 0, 0, 0, 0, timestamp.Location())
-                        }
-
-                        dc.SendMessage(&irc.Message{
-                                Prefix:  dc.srv.prefix(),
-                                Command: "BATCH",
-                                Params:  []string{"-" + batchRef},
-                        })
+                        history, err = loadHistoryAfterTime(uc.network, entity, timestamp, limit)
                 default:
                         // TODO: support LATEST, BETWEEN
@@ -1682 +1612 @@
                         }}
                 }
+                if err != nil {
+                        dc.logger.Printf("failed parsing log messages for chathistory: %v", err)
+                        return newChatHistoryError(subcommand, target)
+                }
+
+                batchRef := "history"
+                dc.SendMessage(&irc.Message{
+                        Prefix:  dc.srv.prefix(),
+                        Command: "BATCH",
+                        Params:  []string{"+" + batchRef, "chathistory", target},
+                })
+
+                for _, msg := range history {
+                        msg.Tags["batch"] = irc.TagValue(batchRef)
+                        dc.SendMessage(dc.marshalMessage(msg, uc.network))
+                }
+
+                dc.SendMessage(&irc.Message{
+                        Prefix:  dc.srv.prefix(),
+                        Command: "BATCH",
+                        Params:  []string{"-" + batchRef},
+                })
         default:
                 dc.logger.Printf("unhandled message: %v", msg)

trunk/logger.go

@@ -11 +11 @@
         "gopkg.in/irc.v3"
 )
+
+const messageLoggerMaxTries = 100
 
 type messageLogger struct {
@@ -245 +247 @@
         return history, nil
 }
+
+func loadHistoryBeforeTime(network *network, entity string, t time.Time, limit int) ([]*irc.Message, error) {
+        history := make([]*irc.Message, limit)
+        remaining := limit
+        tries := 0
+        for remaining > 0 && tries < messageLoggerMaxTries {
+                buf, err := parseMessagesBefore(network, entity, t, remaining)
+                if err != nil {
+                        return nil, err
+                }
+                if len(buf) == 0 {
+                        tries++
+                } else {
+                        tries = 0
+                }
+                copy(history[remaining-len(buf):], buf)
+                remaining -= len(buf)
+                year, month, day := t.Date()
+                t = time.Date(year, month, day, 0, 0, 0, 0, t.Location()).Add(-1)
+        }
+
+        return history[remaining:], nil
+}
+
+func loadHistoryAfterTime(network *network, entity string, t time.Time, limit int) ([]*irc.Message, error) {
+        var history []*irc.Message
+        remaining := limit
+        tries := 0
+        now := time.Now()
+        for remaining > 0 && tries < messageLoggerMaxTries && t.Before(now) {
+                buf, err := parseMessagesAfter(network, entity, t, remaining)
+                if err != nil {
+                        return nil, err
+                }
+                if len(buf) == 0 {
+                        tries++
+                } else {
+                        tries = 0
+                }
+                history = append(history, buf...)
+                remaining -= len(buf)
+                year, month, day := t.Date()
+                t = time.Date(year, month, day+1, 0, 0, 0, 0, t.Location())
+        }
+        return history, nil
+}