source: code/trunk/logger.go@ 389

package soju

import (
        "bufio"
        "fmt"
        "os"
        "path/filepath"
        "strings"
        "time"

        "gopkg.in/irc.v3"
)

const messageLoggerMaxTries = 100

type messageLogger struct {
        network *network
        entity  string

        path string
        file *os.File
}

func newMessageLogger(network *network, entity string) *messageLogger {
        return &messageLogger{
                network: network,
                entity:  entity,
        }
}

func logPath(network *network, entity string, t time.Time) string {
        user := network.user
        srv := user.srv

        // TODO: handle/forbid network/entity names with illegal path characters
        year, month, day := t.Date()
        filename := fmt.Sprintf("%04d-%02d-%02d.log", year, month, day)
        return filepath.Join(srv.LogPath, user.Username, network.GetName(), entity, filename)
}

func (ml *messageLogger) Append(msg *irc.Message) error {
        s := formatMessage(msg)
        if s == "" {
                return nil
        }

        var t time.Time
        if tag, ok := msg.Tags["time"]; ok {
                var err error
                t, err = time.Parse(serverTimeLayout, string(tag))
                if err != nil {
                        return fmt.Errorf("failed to parse message time tag: %v", err)
                }
                t = t.In(time.Local)
        } else {
                t = time.Now()
        }

        // TODO: enforce maximum open file handles (LRU cache of file handles)
        // TODO: handle non-monotonic clock behaviour
        path := logPath(ml.network, ml.entity, t)
        if ml.path != path {
                if ml.file != nil {
                        ml.file.Close()
                }

                dir := filepath.Dir(path)
                if err := os.MkdirAll(dir, 0700); err != nil {
                        return fmt.Errorf("failed to create logs directory %q: %v", dir, err)
                }

                f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0600)
                if err != nil {
                        return fmt.Errorf("failed to open log file %q: %v", path, err)
                }

                ml.path = path
                ml.file = f
        }

        _, err := fmt.Fprintf(ml.file, "[%02d:%02d:%02d] %s\n", t.Hour(), t.Minute(), t.Second(), s)
        if err != nil {
                return fmt.Errorf("failed to log message to %q: %v", ml.path, err)
        }
        return nil
}

func (ml *messageLogger) Close() error {
        if ml.file == nil {
                return nil
        }
        return ml.file.Close()
}

// formatMessage formats a message log line. It assumes a well-formed IRC
// message.
func formatMessage(msg *irc.Message) string {
        switch strings.ToUpper(msg.Command) {
        case "NICK":
                return fmt.Sprintf("*** %s is now known as %s", msg.Prefix.Name, msg.Params[0])
        case "JOIN":
                return fmt.Sprintf("*** Joins: %s (%s@%s)", msg.Prefix.Name, msg.Prefix.User, msg.Prefix.Host)
        case "PART":
                var reason string
                if len(msg.Params) > 1 {
                        reason = msg.Params[1]
                }
                return fmt.Sprintf("*** Parts: %s (%s@%s) (%s)", msg.Prefix.Name, msg.Prefix.User, msg.Prefix.Host, reason)
        case "KICK":
                nick := msg.Params[1]
                var reason string
                if len(msg.Params) > 2 {
                        reason = msg.Params[2]
                }
                return fmt.Sprintf("*** %s was kicked by %s (%s)", nick, msg.Prefix.Name, reason)
        case "QUIT":
                var reason string
                if len(msg.Params) > 0 {
                        reason = msg.Params[0]
                }
                return fmt.Sprintf("*** Quits: %s (%s@%s) (%s)", msg.Prefix.Name, msg.Prefix.User, msg.Prefix.Host, reason)
        case "TOPIC":
                var topic string
                if len(msg.Params) > 1 {
                        topic = msg.Params[1]
                }
                return fmt.Sprintf("*** %s changes topic to '%s'", msg.Prefix.Name, topic)
        case "MODE":
                return fmt.Sprintf("*** %s sets mode: %s", msg.Prefix.Name, strings.Join(msg.Params[1:], " "))
        case "NOTICE":
                return fmt.Sprintf("-%s- %s", msg.Prefix.Name, msg.Params[1])
        case "PRIVMSG":
                return fmt.Sprintf("<%s> %s", msg.Prefix.Name, msg.Params[1])
        default:
                return ""
        }
}

func parseMessage(line, entity string, ref time.Time) (*irc.Message, time.Time, error) {
        var hour, minute, second int
        _, err := fmt.Sscanf(line, "[%02d:%02d:%02d] ", &hour, &minute, &second)
        if err != nil {
                return nil, time.Time{}, err
        }
        line = line[11:]

        // TODO: support NOTICE
        if !strings.HasPrefix(line, "<") {
                return nil, time.Time{}, nil
        }
        i := strings.Index(line, "> ")
        if i < 0 {
                return nil, time.Time{}, nil
        }

        year, month, day := ref.Date()
        t := time.Date(year, month, day, hour, minute, second, 0, time.Local)

        sender := line[1:i]
        text := line[i+2:]
        msg := &irc.Message{
                Tags: map[string]irc.TagValue{
                        "time": irc.TagValue(t.UTC().Format(serverTimeLayout)),
                },
                Prefix:  &irc.Prefix{Name: sender},
                Command: "PRIVMSG",
                Params:  []string{entity, text},
        }
        return msg, t, nil
}

func parseMessagesBefore(network *network, entity string, ref time.Time, limit int) ([]*irc.Message, error) {
        path := logPath(network, entity, ref)
        f, err := os.Open(path)
        if err != nil {
                if os.IsNotExist(err) {
                        return nil, nil
                }
                return nil, err
        }
        defer f.Close()

        historyRing := make([]*irc.Message, limit)
        cur := 0

        sc := bufio.NewScanner(f)
        for sc.Scan() {
                msg, t, err := parseMessage(sc.Text(), entity, ref)
                if err != nil {
                        return nil, err
                } else if msg == nil {
                        continue
                } else if !t.Before(ref) {
                        break
                }

                historyRing[cur%limit] = msg
                cur++
        }
        if sc.Err() != nil {
                return nil, sc.Err()
        }

        n := limit
        if cur < limit {
                n = cur
        }
        start := (cur - n + limit) % limit

        if start+n <= limit { // ring doesnt wrap
                return historyRing[start : start+n], nil
        } else { // ring wraps
                history := make([]*irc.Message, n)
                r := copy(history, historyRing[start:])
                copy(history[r:], historyRing[:n-r])
                return history, nil
        }
}

func parseMessagesAfter(network *network, entity string, ref time.Time, limit int) ([]*irc.Message, error) {
        path := logPath(network, entity, ref)
        f, err := os.Open(path)
        if err != nil {
                if os.IsNotExist(err) {
                        return nil, nil
                }
                return nil, err
        }
        defer f.Close()

        var history []*irc.Message
        sc := bufio.NewScanner(f)
        for sc.Scan() && len(history) < limit {
                msg, t, err := parseMessage(sc.Text(), entity, ref)
                if err != nil {
                        return nil, err
                } else if msg == nil || !t.After(ref) {
                        continue
                }

                history = append(history, msg)
        }
        if sc.Err() != nil {
                return nil, sc.Err()
        }

        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
}