botopolis/bot

package bot

import (
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/gorilla/mux"
)

const timeout = 15

// Robot is the central structure for bot
type Robot struct {
    // Chat adapter
    Chat Chat
    // Data store
    Brain *Brain
    // HTTP Router
    Router *mux.Router
    // Logger with levels
    Logger Logger

    plugins   *pluginRegistry
    internals *pluginRegistry
    queue     *responderQueue
}

// New creates an instance of a bot.Robot and loads in the chat adapter
// Typically you would install plugins before running the robot.
func New(c Chat, plugins ...Plugin) *Robot {
    r := &Robot{
        Chat:   c,
        Brain:  NewBrain(),
        Router: mux.NewRouter(),
        Logger: defaultLogger,

        plugins:   newPluginRegistry(),
        internals: newPluginRegistry(),
        queue:     newResponderQueue(10),
    }
    r.internals.Add(
        c,
        newServer(":"+os.Getenv("PORT")),
    )
    r.plugins.Add(plugins...)
    return r
}

// Plugin allows you to fetch a loaded plugin for direct use
// See ExamplePluginUsage
func (r *Robot) Plugin(p Plugin) bool {
    ok := r.plugins.Get(p)
    if !ok {
        return r.internals.Get(p)
    }
    return ok
}

// ListPlugins returns a slice of all loaded plugins.
func (r *Robot) ListPlugins() []Plugin {
    return append(r.internals.List(), r.plugins.List()...)
}

// Run is responsible for:
// 1. Loading internals (chat, http)
// 2. Loading all plugins
// 3. Running RTM Slack until termination
// 4. Unloading all plugins in reverse order
// 5. Unloading internals in reverse order
func (r *Robot) Run() {
    r.gracefulShutdown()
    r.internals.Load(r)
    r.plugins.Load(r)
    r.queue.Forward(r, r.Chat.Messages())
    r.stop()
}

func (r *Robot) gracefulShutdown() {
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        done := make(chan bool)
        go func() {
            r.stop()
            done <- true
        }()
        select {
        case <-time.After(timeout * time.Second):
            r.Logger.Infof("Force quitting after %ds timeout", timeout)
            os.Exit(1)
        case <-done:
            os.Exit(0)
        }
    }()
}

func (r *Robot) stop() {
    r.Logger.Info("Shutting down...")
    r.plugins.Unload(r)
    r.internals.Unload(r)
}

func (r *Robot) onMessage(t messageType, m Matcher, h hook) {
    if m == nil || h == nil {
        return
    }
    for rs := range r.queue.On(t) {
        if m(&rs) {
            if err := h(rs); err != nil {
                r.Logger.Errorf("Hook error: %s", err.Error())
            }
        }
    }
}

// Hear is triggered on any message event.
func (r *Robot) Hear(m Matcher, h hook) { go r.onMessage(DefaultMessage, m, h) }

// Respond is triggered on messages to the bot
func (r *Robot) Respond(m Matcher, h hook) { go r.onMessage(Response, m, h) }

// Enter is triggered when someone enters a room
func (r *Robot) Enter(h hook) { go r.onMessage(Enter, nil, h) }

// Leave is triggered when someone leaves a room
func (r *Robot) Leave(h hook) { go r.onMessage(Leave, nil, h) }

// Topic is triggered when someone changes the topic
func (r *Robot) Topic(h hook) { go r.onMessage(Topic, nil, h) }

// Username provides the robot's username
func (r *Robot) Username() string { return r.Chat.Username() }