Initial Commit

cmd/app.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+type App struct {
+	DebugMode bool
+	running   bool
+
+	m *BotModel
+
+	plugins []HelperPlugin
+}
+
+func NewApp() (*App, error) {
+	a := new(App)
+	if DebugMode {
+		fmt.Println("Running in Debug Mode. All messages will be sent to Admin DM")
+	}
+	a.DebugMode = DebugMode
+
+	err := a.initialize()
+	if err != nil {
+		return nil, err
+	}
+	a.running = true
+
+	go a.MonitorSlackMessages()
+	return a, nil
+}
+
+func (a *App) initialize() error {
+	var err error
+	if a.m, err = NewBotModel(); err != nil {
+		return err
+	}
+
+	reader := bufio.NewReader(os.Stdin)
+	// Load up the plugins
+	pluginDir := strings.TrimSpace(a.m.getPluginDir())
+	a.LoadPluginsFromDirectory(pluginDir)
+	if err != nil {
+		fmt.Println("Error loading plugins")
+		fmt.Println(err.Error())
+		os.Exit(1)
+	}
+
+	// Now initialize the Slack stuff
+	var slackToken, slackDMid string
+	slackToken, err = a.m.getSlackToken()
+	if err != nil || slackToken == "" {
+		fmt.Print("Slack API Token: ")
+		slackToken, _ = reader.ReadString('\n')
+		a.m.setSlackToken(strings.TrimSpace(slackToken))
+	}
+	slackDMid, err = a.m.getSlackAdminDMId()
+	if err != nil || slackDMid == "" {
+		fmt.Print("Slack Admin DM ID: ")
+		slackDMid, _ = reader.ReadString('\n')
+		a.m.setSlackAdminDMId(strings.TrimSpace(slackDMid))
+	}
+
+	if err = a.m.NewSlack(); err != nil {
+		return err
+	}
+
+	go a.watchMessageChannel()
+	return nil
+}
+
+func (a *App) watchMessageChannel() {
+	for a.running {
+		msg := <-a.m.messages
+		slackMsg := msg.GetMessage()
+		if slackMsg.Type == "control" && slackMsg.Name == "quit" {
+			a.running = false
+			break
+		} else if msg.GetDestination() == "slack" {
+			a.m.SendSlackChannelMessage(&slackMsg)
+		}
+
+		for _, v := range a.plugins {
+			v.State.ProcessMessage(msg)
+		}
+	}
+	close(a.m.messages)
+}

cmd/helper_plugin.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"plugin"
+
+	"git.bullercodeworks.com/brian/helperbot"
+)
+
+type HelperPlugin struct {
+	p *plugin.Plugin
+
+	State helperbot.PluginState
+}
+
+func (a *App) LoadPluginsFromDirectory(dir string) error {
+	fmt.Println("Loading Plugins (", dir, ")")
+	files, err := ioutil.ReadDir(dir)
+	if err != nil {
+		fmt.Println("Error loading plugins")
+		fmt.Println(err.Error())
+		os.Exit(1)
+	}
+	for _, f := range files {
+		p, err := plugin.Open(dir + f.Name())
+		if err != nil {
+			fmt.Println(fmt.Sprintf("Error loading plugin (%s)\n", f.Name()))
+			fmt.Println(err.Error())
+			os.Exit(1)
+		}
+		hp, err := NewHelperPlugin(p)
+		if err != nil {
+			fmt.Println(fmt.Sprintf("Error loading plugin (%s)\n", f.Name()))
+			fmt.Println(err.Error())
+			os.Exit(1)
+		}
+		hp.State.Initialize(a.m)
+		hp.State.Run()
+		a.plugins = append(a.plugins, *hp)
+	}
+	return nil
+}
+
+func NewHelperPlugin(p *plugin.Plugin) (*HelperPlugin, error) {
+	h := &HelperPlugin{
+		p: p,
+	}
+
+	// Parse the plugin's state
+	pluginStateSymbol, err := p.Lookup("State")
+	if err != nil {
+		return nil, err
+	}
+	h.State = pluginStateSymbol.(helperbot.PluginState)
+	return h, nil
+}

cmd/helpers.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"encoding/json"
+
+	slack "git.bullercodeworks.com/brian/go-slack"
+)
+
+func GetMessageJson(msg *slack.Message) string {
+	if mb, me := json.Marshal(msg); me == nil {
+		return string(mb)
+	}
+	return ""
+}

cmd/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	slack "git.bullercodeworks.com/brian/go-slack"
+)
+
+var DebugMode = false
+
+var a *App
+
+func main() {
+	if len(os.Args) > 1 {
+		if os.Args[1] == "-debug" || os.Args[1] == "--debug" {
+			DebugMode = true
+		}
+	}
+	a, err := NewApp()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	// Monitor the Advent of Code Boards
+	//go m.MonitorAoCBoards()
+	// Monitor incoming Slack messages
+	//go m.MonitorSlackMessages()
+
+	// Set up a channel to intercept Ctrl+C for graceful shutdowns
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+		// Save the changes when the app quits
+		fmt.Println("\nFinishing up...")
+		a.m.messages <- NewBotMessage("main", "main", slack.Message{Type: "control", Name: "quit"})
+	}()
+	for a.running {
+		time.Sleep(time.Second * 2)
+	}
+	fmt.Println("Model has stopped running")
+	fmt.Println("Done")
+	os.Exit(0)
+}

cmd/message.go

@@ -0,0 +1,21 @@
+package main
+
+import slack "git.bullercodeworks.com/brian/go-slack"
+
+// This message type is for communications over the messages channel
+type BotMessage struct {
+	source  string
+	dest    string
+	message slack.Message
+}
+
+func NewBotMessage(src, dst string, msg slack.Message) BotMessage {
+	return BotMessage{
+		source:  src,
+		dest:    dst,
+		message: msg,
+	}
+}
+func (m BotMessage) GetSource() string         { return m.source }
+func (m BotMessage) GetDestination() string    { return m.dest }
+func (m BotMessage) GetMessage() slack.Message { return m.message }

cmd/model.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+
+	slack "git.bullercodeworks.com/brian/go-slack"
+	"git.bullercodeworks.com/brian/helperbot"
+	"github.com/br0xen/boltease"
+)
+
+type BotModel struct {
+	db *boltease.DB
+
+	messages chan helperbot.Message
+
+	slack *slack.Slack
+
+	cache map[string][]byte
+}
+
+func NewBotModel() (*BotModel, error) {
+	var err error
+	m := new(BotModel)
+	m.cache = make(map[string][]byte)
+	m.messages = make(chan helperbot.Message, 100)
+	m.db, err = boltease.Create("helperbot.db", 0600, nil)
+	if err != nil {
+		return nil, err
+	}
+	m.db.MkBucketPath([]string{"slack", "users"})
+	m.db.MkBucketPath([]string{"slack", "channels"})
+
+	return m, nil
+}
+
+func (m *BotModel) SendMessage(src, dst string, msg slack.Message) {
+	m.messages <- NewBotMessage(src, dst, msg)
+}
+
+func (m *BotModel) getPluginDir() string {
+	ret, err := m.GetString([]string{"config", "plugin_dir"})
+	if err != nil || strings.TrimSpace(ret) == "" {
+		ret = "./plugins/"
+		if err = m.SetString([]string{"config", "plugin_dir"}, ret); err != nil {
+			fmt.Println("Error setting plugin directory")
+			fmt.Println(err.Error())
+			os.Exit(1)
+		}
+	}
+	fmt.Println("Plugin Dir: ", ret)
+	return ret
+}
+
+func (m *BotModel) GetBytes(path []string) ([]byte, error) {
+	var err error
+	var v []byte
+	var ok bool
+	joinedPath := strings.Join(path, "/")
+	if v, ok = m.cache[joinedPath]; !ok {
+		// Value is not cached, try to pull it from the DB
+		if len(path) > 2 {
+			path, key := path[:len(path)-1], path[len(path)-1]
+			v, err = m.db.GetBytes(path, key)
+			if err != nil {
+				return nil, err
+			}
+			m.cache[joinedPath] = v
+		}
+	}
+	return v, nil
+}
+
+func (m *BotModel) SetBytes(path []string, val []byte) error {
+	if len(path) > 1 {
+		joinedPath := strings.Join(path, "/")
+		path, key := path[:len(path)-1], path[len(path)-1]
+		err := m.db.SetBytes(path, key, val)
+		if err != nil {
+			return err
+		}
+		// Update the cache
+		m.cache[joinedPath] = val
+		return nil
+	}
+	return errors.New("Invalid path")
+}
+
+func (m *BotModel) GetString(path []string) (string, error) {
+	bts, err := m.GetBytes(path)
+	if err != nil {
+		return "", err
+	}
+	return string(bts), nil
+}
+
+func (m *BotModel) SetString(path []string, val string) error {
+	return m.SetBytes(path, []byte(val))
+}

cmd/model_slack.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	slack "git.bullercodeworks.com/brian/go-slack"
+)
+
+/* DB Functions */
+func (m *BotModel) setSlackToken(token string) error {
+	return m.SetBytes([]string{"slack", "config", "token"}, []byte(token))
+}
+
+func (m *BotModel) getSlackToken() (string, error) {
+	return m.GetString([]string{"slack", "config", "token"})
+}
+
+func (m *BotModel) setSlackAdminDMId(adminId string) error {
+	return m.SetString([]string{"slack", "config", "admin_dm_id"}, adminId)
+}
+
+func (m *BotModel) getSlackAdminDMId() (string, error) {
+	return m.GetString([]string{"slack", "config", "admin_dm_id"})
+}
+
+func (m *BotModel) setSlackChannelId(chanId string) error {
+	return m.SetString([]string{"slack", "config", "channel_id"}, chanId)
+}
+
+func (m *BotModel) getSlackChannelId() (string, error) {
+	return m.GetString([]string{"slack", "config", "channel_id"})
+}
+
+/* End DB Functions */
+
+func (m *BotModel) NewSlack() error {
+	token, err := m.getSlackToken()
+	if err != nil {
+		return err
+	}
+	if m.slack, err = slack.CreateSlack(token); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (a *App) MonitorSlackMessages() {
+	for a.running {
+		msg, err := a.m.slack.GetMessage()
+		if err == nil {
+			a.m.SendMessage("slack", "main", msg)
+		}
+	}
+}
+
+func (m *BotModel) SendSlackChannelMessage(msg *slack.Message) error {
+	if DebugMode {
+		return m.SendSlackAdminMessage(msg)
+	}
+	// Send message to slack channel
+	var err error
+	if err = m.slack.PostMessage(*msg); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m *BotModel) SendSlackAdminMessage(msg *slack.Message) error {
+	// Send message to slack admin
+	var err error
+	msg.Channel, err = m.getSlackAdminDMId()
+	if err != nil {
+		return err
+	}
+	if err = m.slack.PostMessage(*msg); err != nil {
+		return err
+	}
+	return nil
+}