Keep recovery advice out of log events

[onechat] / log.go

diff --git a/log.go b/log.go
index 6d0d4784dfa9390f9f4a905d7c95539104be338a..1ed70e78e36aaccaf862118cfe56c95fa107c671 100644 (file)
--- a/log.go
+++ b/log.go
@@ -21,6 +21,38 @@ var logKinds = map[string]bool{
        "note":  true,
 }
 
        "note":  true,
 }
 

+// Log is the append-only message log of one chat. It writes one JSON line for
+// each message to main/YYYY-MM-DD.jsonl, named for the local day of the
+// message. It never edits or deletes a line. Each line goes to the operating
+// system before Append returns, so a crash of the process loses no message. An
+// exclusive lock on the lock file makes sure that only one process writes the
+// log. After a failed write, the end of the file is not known, so the log
+// refuses all writes until it is opened again. The caller serializes all calls.
+//
+// The log keeps no message in memory. The index index/main.idx holds the
+// position of message i in record i, so a read of a message is one read of the
+// index and one of its day file. At open the log indexes the lines after the
+// last indexed one, so a missing index is built again from the day files.
+type Log struct {
+       clock   func() time.Time
+       lock    *os.File
+       journal Journal
+       index   *Records
+       failure error
+}
+
+// Message is one entry of the chat log. ID is its position in the log, from 0.
+// A rebuild assigns positions in the merged log. Size is the UTF-8 byte length
+// of Text. Date is the message time in RFC 3339 format, supplied at append or
+// taken from the clock.
+type Message struct {
+       ID   int    `json:"i"`
+       Kind string `json:"kind"`
+       Text string `json:"text"`
+       Size int    `json:"size"`
+       Date string `json:"date"`
+}
+

 // openLog locks the chat in root and indexes its new lines. The clock gives the
 // date of each new message.
 func openLog(ctx context.Context, root string, clock func() time.Time) (*Log, error) {
 // openLog locks the chat in root and indexes its new lines. The clock gives the
 // date of each new message.
 func openLog(ctx context.Context, root string, clock func() time.Time) (*Log, error) {


@@ -57,26 +89,6 @@ func openLog(ctx context.Context, root string, clock func() time.Time) (*Log, er
        return l, nil
 }
 
        return l, nil
 }
 

-// Log is the append-only message log of one chat. It writes one JSON line for
-// each message to main/YYYY-MM-DD.jsonl, named for the local day of the
-// message. It never edits or deletes a line. Each line goes to the operating
-// system before Append returns, so a crash of the process loses no message. An
-// exclusive lock on the lock file makes sure that only one process writes the
-// log. After a failed write, the end of the file is not known, so the log
-// refuses all writes until it is opened again. The caller serializes all calls.
-//
-// The log keeps no message in memory. The index index/main.idx holds the
-// position of message i in record i, so a read of a message is one read of the
-// index and one of its day file. At open the log indexes the lines after the
-// last indexed one, so a missing index is built again from the day files.
-type Log struct {
-       clock   func() time.Time
-       lock    *os.File
-       journal Journal
-       index   *Records
-       failure error
-}
-

 // Close releases the lock. The log refuses all calls after Close.
 func (l *Log) Close() error {
        err := l.journal.Close()
 // Close releases the lock. The log refuses all calls after Close.
 func (l *Log) Close() error {
        err := l.journal.Close()


@@ -93,6 +105,50 @@ func (l *Log) Close() error {
        return err
 }
 
        return err
 }
 

+// catchUp indexes the lines after the last indexed line.
+func (l *Log) catchUp(ctx context.Context) error {
+       start := Position{}
+       if l.index.count > 0 {
+               record, _, err := l.index.Read(l.index.count - 1)
+               if err != nil {
+                       return err
+               }
+
+               last := decodePosition(record)
+               start = Position{
+                       day:    last.day,
+                       offset: last.offset + uint64(last.length),
+               }
+       }
+
+       return l.journal.Scan(ctx, start, func(line []byte, place Position) error {
+               var message Message
+
+               err := json.Unmarshal(line, &message)
+               if err != nil {
+                       return fmt.Errorf("decode log message: %w", err)
+               }
+
+               if message.ID != l.index.count {
+                       return fmt.Errorf("expected message %d, found %d", l.index.count, message.ID)
+               }
+
+               err = logValidateMessage(message)
+               if err != nil {
+                       return fmt.Errorf("message %d: %w", message.ID, err)
+               }
+
+               return l.addIndex(place)
+       })
+}
+
+func (l *Log) addIndex(place Position) error {
+       record := make([]byte, positionBytes)
+       encodePosition(record, place)
+
+       return l.index.Append(record)
+}
+

 // Append writes a new message to the log and returns it with its ID, size, and
 // date.
 func (l *Log) Append(kind, text string) (Message, error) {
 // Append writes a new message to the log and returns it with its ID, size, and
 // date.
 func (l *Log) Append(kind, text string) (Message, error) {


@@ -190,62 +246,6 @@ func (l *Log) Message(id int) (Message, error) {
        return message, nil
 }
 
        return message, nil
 }
 

-// catchUp indexes the lines after the last indexed line.
-func (l *Log) catchUp(ctx context.Context) error {
-       start := Position{}
-       if l.index.count > 0 {
-               record, _, err := l.index.Read(l.index.count - 1)
-               if err != nil {
-                       return err
-               }
-
-               last := decodePosition(record)
-               start = Position{
-                       day:    last.day,
-                       offset: last.offset + uint64(last.length),
-               }
-       }
-
-       return l.journal.Scan(ctx, start, func(line []byte, place Position) error {
-               var message Message
-
-               err := json.Unmarshal(line, &message)
-               if err != nil {
-                       return fmt.Errorf("decode log message: %w", err)
-               }
-
-               if message.ID != l.index.count {
-                       return fmt.Errorf("expected message %d, found %d", l.index.count, message.ID)
-               }
-
-               err = logValidateMessage(message)
-               if err != nil {
-                       return fmt.Errorf("message %d: %w", message.ID, err)
-               }
-
-               return l.addIndex(place)
-       })
-}
-
-func (l *Log) addIndex(place Position) error {
-       record := make([]byte, positionBytes)
-       encodePosition(record, place)
-
-       return l.index.Append(record)
-}
-
-// Message is one entry of the chat log. ID is its position in the log, from 0.
-// A rebuild assigns positions in the merged log. Size is the UTF-8 byte length
-// of Text. Date is the message time in RFC 3339 format, supplied at append or
-// taken from the clock.
-type Message struct {
-       ID   int    `json:"i"`
-       Kind string `json:"kind"`
-       Text string `json:"text"`
-       Size int    `json:"size"`
-       Date string `json:"date"`
-}
-

 // logValidateMessage makes sure that a message has a known kind, valid UTF-8
 // text, the size of its text, and a valid date.
 func logValidateMessage(message Message) error {
 // logValidateMessage makes sure that a message has a known kind, valid UTF-8
 // text, the size of its text, and a valid date.
 func logValidateMessage(message Message) error {