Changeset 516 in code

Timestamp:

May 18, 2021, 8:44:10 AM (4 years ago)

Author:

hubert

Message:

Implement CHATHISTORY BETWEEN

Location:

trunk

Files:

• downstream.go (modified) (3 diffs)
• irc.go (modified) (2 diffs)
• msgstore.go (modified) (1 diff)
• msgstore_fs.go (modified) (9 diffs)

trunk/downstream.go

@@ -1802 +1802 @@
                         return err
                 }
-                var target, criteria, limitStr string
-                if err := parseMessageParams(msg, nil, &target, &criteria, &limitStr); err != nil {
+                var target, limitStr string
+                var boundsStr [2]string
+                switch subcommand {
+                case "AFTER", "BEFORE":
+                        if err := parseMessageParams(msg, nil, &target, &boundsStr[0], &limitStr); err != nil {
+                                return err
+                        }
+                case "BETWEEN":
+                        if err := parseMessageParams(msg, nil, &target, &boundsStr[0], &boundsStr[1], &limitStr); err != nil {
+                                return err
+                        }
+                default:
+                        // TODO: support LATEST, AROUND
                         return ircError{&irc.Message{
                                 Command: "FAIL",
-                                Params:  []string{"CHATHISTORY", "NEED_MORE_PARAMS", subcommand, "Missing parameters"},
+                                Params:  []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, "Unknown command"},
                         }}
                 }
@@ -1825 +1836 @@
 
                 // TODO: support msgid criteria
-                criteriaParts := strings.SplitN(criteria, "=", 2)
-                if len(criteriaParts) != 2 || criteriaParts[0] != "timestamp" {
+                var bounds [2]time.Time
+                bounds[0] = parseChatHistoryBound(boundsStr[0])
+                if bounds[0].IsZero() {
                         return ircError{&irc.Message{
                                 Command: "FAIL",
-                                Params:  []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, criteria, "Unknown criteria"},
+                                Params:  []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, boundsStr[0], "Invalid first bound"},
                         }}
                 }
 
-                timestamp, err := time.Parse(serverTimeLayout, criteriaParts[1])
-                if err != nil {
-                        return ircError{&irc.Message{
-                                Command: "FAIL",
-                                Params:  []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, criteria, "Invalid criteria"},
-                        }}
+                if boundsStr[1] != "" {
+                        bounds[1] = parseChatHistoryBound(boundsStr[1])
+                        if bounds[1].IsZero() {
+                                return ircError{&irc.Message{
+                                        Command: "FAIL",
+                                        Params:  []string{"CHATHISTORY", "INVALID_PARAMS", subcommand, boundsStr[1], "Invalid second bound"},
+                                }}
+                        }
                 }
 
@@ -1852 +1866 @@
                 switch subcommand {
                 case "BEFORE":
-                        history, err = store.LoadBeforeTime(uc.network, entity, timestamp, limit)
+                        history, err = store.LoadBeforeTime(uc.network, entity, bounds[0], time.Time{}, limit)
                 case "AFTER":
-                        history, err = store.LoadAfterTime(uc.network, entity, timestamp, limit)
-                default:
-                        // TODO: support LATEST, BETWEEN
-                        return ircError{&irc.Message{
-                                Command: "FAIL",
-                                Params:  []string{"CHATHISTORY", "UNKNOWN_COMMAND", subcommand, "Unknown command"},
-                        }}
+                        history, err = store.LoadAfterTime(uc.network, entity, bounds[0], time.Now(), limit)
+                case "BETWEEN":
+                        if bounds[0].Before(bounds[1]) {
+                                history, err = store.LoadAfterTime(uc.network, entity, bounds[0], bounds[1], limit)
+                        } else {
+                                history, err = store.LoadBeforeTime(uc.network, entity, bounds[0], bounds[1], limit)
+                        }
                 }
                 if err != nil {

trunk/irc.go

@@ -5 +5 @@
         "sort"
         "strings"
+        "time"
         "unicode"
         "unicode/utf8"
@@ -638 +639 @@
         }
 }
+
+// parseChatHistoryBound parses the given CHATHISTORY parameter as a bound.
+// The zero time is returned on error.
+func parseChatHistoryBound(param string) time.Time {
+        parts := strings.SplitN(param, "=", 2)
+        if len(parts) != 2 {
+                return time.Time{}
+        }
+        switch parts[0] {
+        case "timestamp":
+                timestamp, err := time.Parse(serverTimeLayout, parts[1])
+                if err != nil {
+                        return time.Time{}
+                }
+                return timestamp
+        default:
+                return time.Time{}
+        }
+}

trunk/msgstore.go

@@ -27 +27 @@
         messageStore
 
-        LoadBeforeTime(network *network, entity string, t time.Time, limit int) ([]*irc.Message, error)
-        LoadAfterTime(network *network, entity string, t time.Time, limit int) ([]*irc.Message, error)
+        // LoadBeforeTime loads up to limit messages before start down to end. The
+        // returned messages must be between and excluding the provided bounds.
+        // end is before start.
+        LoadBeforeTime(network *network, entity string, start, end time.Time, limit int) ([]*irc.Message, error)
+        // LoadBeforeTime loads up to limit messages after start up to end. The
+        // returned messages must be between and excluding the provided bounds.
+        // end is after start.
+        LoadAfterTime(network *network, entity string, start, end time.Time, limit int) ([]*irc.Message, error)
 }
 

trunk/msgstore_fs.go

@@ -258 +258 @@
 }
 
-func (ms *fsMessageStore) parseMessagesBefore(network *network, entity string, ref time.Time, limit int, afterOffset int64) ([]*irc.Message, error) {
+func (ms *fsMessageStore) parseMessagesBefore(network *network, entity string, ref time.Time, end time.Time, limit int, afterOffset int64) ([]*irc.Message, error) {
         path := ms.logPath(network, entity, ref)
         f, err := os.Open(path)
@@ -285 +285 @@
                 if err != nil {
                         return nil, err
-                } else if msg == nil {
+                } else if msg == nil || !t.After(end) {
                         continue
                 } else if !t.Before(ref) {
@@ -314 +314 @@
 }
 
-func (ms *fsMessageStore) parseMessagesAfter(network *network, entity string, ref time.Time, limit int) ([]*irc.Message, error) {
+func (ms *fsMessageStore) parseMessagesAfter(network *network, entity string, ref time.Time, end time.Time, limit int) ([]*irc.Message, error) {
         path := ms.logPath(network, entity, ref)
         f, err := os.Open(path)
@@ -333 +333 @@
                 } else if msg == nil || !t.After(ref) {
                         continue
+                } else if !t.Before(end) {
+                        break
                 }
 
@@ -344 +346 @@
 }
 
-func (ms *fsMessageStore) LoadBeforeTime(network *network, entity string, t time.Time, limit int) ([]*irc.Message, error) {
+func (ms *fsMessageStore) LoadBeforeTime(network *network, entity string, start time.Time, end time.Time, limit int) ([]*irc.Message, error) {
         history := make([]*irc.Message, limit)
         remaining := limit
         tries := 0
-        for remaining > 0 && tries < fsMessageStoreMaxTries {
-                buf, err := ms.parseMessagesBefore(network, entity, t, remaining, -1)
+        for remaining > 0 && tries < fsMessageStoreMaxTries && end.Before(start) {
+                buf, err := ms.parseMessagesBefore(network, entity, start, end, remaining, -1)
                 if err != nil {
                         return nil, err
@@ -360 +362 @@
                 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)
+                year, month, day := start.Date()
+                start = time.Date(year, month, day, 0, 0, 0, 0, start.Location()).Add(-1)
         }
 
@@ -367 +369 @@
 }
 
-func (ms *fsMessageStore) LoadAfterTime(network *network, entity string, t time.Time, limit int) ([]*irc.Message, error) {
+func (ms *fsMessageStore) LoadAfterTime(network *network, entity string, start time.Time, end time.Time, limit int) ([]*irc.Message, error) {
         var history []*irc.Message
         remaining := limit
         tries := 0
-        now := time.Now()
-        for remaining > 0 && tries < fsMessageStoreMaxTries && t.Before(now) {
-                buf, err := ms.parseMessagesAfter(network, entity, t, remaining)
+        for remaining > 0 && tries < fsMessageStoreMaxTries && start.Before(end) {
+                buf, err := ms.parseMessagesAfter(network, entity, start, end, remaining)
                 if err != nil {
                         return nil, err
@@ -384 +385 @@
                 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())
+                year, month, day := start.Date()
+                start = time.Date(year, month, day+1, 0, 0, 0, 0, start.Location())
         }
         return history, nil
@@ -421 +422 @@
                 }
 
-                buf, err := ms.parseMessagesBefore(network, entity, t, remaining, offset)
+                buf, err := ms.parseMessagesBefore(network, entity, t, time.Time{}, remaining, offset)
                 if err != nil {
                         return nil, err