add support to run darwinbot on keybase chat (#67)

Author: mmaxim

bot.go

@@ -11,103 +11,89 @@ import (
 	"sort"
 	"strings"
 	"text/tabwriter"
-
-	"github.com/nlopes/slack"
 )
 
-// Bot describes a generic bot
-type Bot interface {
-	Name() string
-	Config() Config
-	AddCommand(trigger string, command Command)
+type BotCommandRunner interface {
+	RunCommand(args []string, channel string) error
+}
+
+type BotBackend interface {
 	SendMessage(text string, channel string)
-	HelpMessage() string
-	SetHelp(help string)
-	Label() string
-	SetDefault(command Command)
-	Listen()
+	Listen(BotCommandRunner)
 }
 
-// SlackBot is a Slack bot
-type SlackBot struct {
-	api            *slack.Client
-	rtm            *slack.RTM
-	commands       map[string]Command
-	defaultCommand Command
-	channelIDs     map[string]string
+// Bot describes a generic bot
+type Bot struct {
+	backend        BotBackend
 	help           string
 	name           string
 	label          string
 	config         Config
+	commands       map[string]Command
+	defaultCommand Command
 }
 
-// NewBot constructs a bot from a Slack token
-func NewBot(token string, name string, label string, config Config) (Bot, error) {
-	api := slack.New(token)
-	//api.SetDebug(true)
-
-	channelIDs, err := LoadChannelIDs(*api)
-	if err != nil {
-		return nil, err
-	}
-
-	bot := newBot(config)
-	bot.api = api
-	bot.rtm = api.NewRTM()
-	bot.channelIDs = channelIDs
-	bot.name = name
-	bot.label = label
-
-	return bot, nil
-}
-
-func newBot(config Config) *SlackBot {
-	bot := SlackBot{
+func NewBot(config Config, name, label string, backend BotBackend) *Bot {
+	return &Bot{
+		backend:  backend,
 		config:   config,
 		commands: make(map[string]Command),
+		name:     name,
+		label:    label,
 	}
-	return &bot
 }
 
-// NewTestBot returns a bot for testing
-func NewTestBot() (Bot, error) {
-	return newBot(NewConfig(true, false)), nil
+func (b *Bot) Name() string {
+	return b.name
 }
 
-// AddCommand adds a command to the Bot
-func (b *SlackBot) AddCommand(trigger string, command Command) {
-	b.commands[trigger] = command
+func (b *Bot) Config() Config {
+	return b.config
 }
 
-// Name returns bot name
-func (b *SlackBot) Name() string {
-	return b.name
+func (b *Bot) AddCommand(trigger string, command Command) {
+	b.commands[trigger] = command
 }
 
-// Label returns bot label
-func (b *SlackBot) Label() string {
-	return b.label
+func (b *Bot) triggers() []string {
+	triggers := make([]string, 0, len(b.commands))
+	for trigger := range b.commands {
+		triggers = append(triggers, trigger)
+	}
+	sort.Strings(triggers)
+	return triggers
 }
 
-// Config returns bot config
-func (b *SlackBot) Config() Config {
-	return b.config
+// HelpMessage is the default help message for the bot
+func (b *Bot) HelpMessage() string {
+	w := new(tabwriter.Writer)
+	buf := new(bytes.Buffer)
+	w.Init(buf, 8, 8, 8, ' ', 0)
+	fmt.Fprintln(w, "Command\tDescription")
+	for _, trigger := range b.triggers() {
+		command := b.commands[trigger]
+		fmt.Fprintln(w, fmt.Sprintf("%s\t%s", trigger, command.Description()))
+	}
+	_ = w.Flush()
+	return BlockQuote(buf.String())
 }
 
-// SetHelp sets the help info
-func (b *SlackBot) SetHelp(help string) {
+func (b *Bot) SetHelp(help string) {
 	b.help = help
 }
 
-// SetDefault is the default command, if no command added for trigger
-func (b *SlackBot) SetDefault(command Command) {
+func (b *Bot) Label() string {
+	return b.label
+}
+
+func (b *Bot) SetDefault(command Command) {
 	b.defaultCommand = command
 }
 
 // RunCommand runs a command
-func (b *SlackBot) RunCommand(args []string, channel string) error {
+func (b *Bot) RunCommand(args []string, channel string) error {
 	if len(args) == 0 || args[0] == "help" {
-		b.SendHelpMessage(channel)
+		b.sendHelpMessage(channel)
 		return nil
 	}
 
@@ -121,128 +107,52 @@ func (b *SlackBot) RunCommand(args []string, channel string) error {
 	}
 
 	if args[0] != "resume" && args[0] != "config" && b.Config().Paused() {
-		b.SendMessage("I can't do that, I'm paused.", channel)
+		b.backend.SendMessage("I can't do that, I'm paused.", channel)
 		return nil
 	}
 
 	go b.run(args, command, channel)
 	return nil
 }
 
-func (b *SlackBot) run(args []string, command Command, channel string) {
+func (b *Bot) run(args []string, command Command, channel string) {
 	out, err := command.Run(channel, args)
 	if err != nil {
 		log.Printf("Error %s running: %#v; %s\n", err, command, out)
-		b.SendMessage(fmt.Sprintf("Oops, there was an error in %q:\n%s", strings.Join(args, " "), SlackBlockQuote(out)), channel)
+		b.backend.SendMessage(fmt.Sprintf("Oops, there was an error in %q:\n%s", strings.Join(args, " "),
+			BlockQuote(out)), channel)
 		return
 	}
 	log.Printf("Output: %s\n", out)
 	if command.ShowResult() {
-		b.SendMessage(out, channel)
+		b.backend.SendMessage(out, channel)
 	}
 }
 
-// SendMessage sends a message to a channel
-func (b *SlackBot) SendMessage(text string, channel string) {
-	cid := b.channelIDs[channel]
-	if cid == "" {
-		cid = channel
-	}
-
-	if channel == "" {
-		log.Printf("No channel to send message: %s", text)
-		return
-	}
-
-	if b.rtm != nil {
-		b.rtm.SendMessage(b.rtm.NewOutgoingMessage(text, cid))
-	} else {
-		log.Printf("Unable to send message: %s", text)
-	}
-}
-
-// Triggers returns list of supported triggers
-func (b *SlackBot) Triggers() []string {
-	triggers := make([]string, 0, len(b.commands))
-	for trigger := range b.commands {
-		triggers = append(triggers, trigger)
-	}
-	sort.Strings(triggers)
-	return triggers
-}
-
-// HelpMessage is the default help message for the bot
-func (b *SlackBot) HelpMessage() string {
-	w := new(tabwriter.Writer)
-	buf := new(bytes.Buffer)
-	w.Init(buf, 8, 8, 8, ' ', 0)
-	fmt.Fprintln(w, "Command\tDescription")
-	for _, trigger := range b.Triggers() {
-		command := b.commands[trigger]
-		fmt.Fprintln(w, fmt.Sprintf("%s\t%s", trigger, command.Description()))
-	}
-	_ = w.Flush()
-
-	return SlackBlockQuote(buf.String())
-}
-
-// SendHelpMessage displays help message to the channel
-func (b *SlackBot) SendHelpMessage(channel string) {
+func (b *Bot) sendHelpMessage(channel string) {
 	help := b.help
 	if help == "" {
 		help = b.HelpMessage()
 	}
-	b.SendMessage(help, channel)
+	b.backend.SendMessage(help, channel)
 }
 
-// Listen starts listening on the connection
-func (b *SlackBot) Listen() {
-	go b.rtm.ManageConnection()
-
-	auth, err := b.api.AuthTest()
-	if err != nil {
-		panic(err)
-	}
-	// The Slack bot "tuxbot" should expect commands to start with "!tuxbot".
-	log.Printf("Connected to Slack as %q", auth.User)
-	commandPrefix := "!" + auth.User
-
-Loop:
-	for {
-		msg := <-b.rtm.IncomingEvents
-		switch ev := msg.Data.(type) {
-		case *slack.HelloEvent:
-
-		case *slack.ConnectedEvent:
-
-		case *slack.MessageEvent:
-			args := parseInput(ev.Text)
-			if len(args) > 0 && args[0] == commandPrefix {
-				cmd := args[1:]
-				b.RunCommand(cmd, ev.Channel)
-			}
-
-		case *slack.PresenceChangeEvent:
-			//log.Printf("Presence Change: %v\n", ev)
-
-		case *slack.LatencyReport:
-			//log.Printf("Current latency: %v\n", ev.Value)
-
-		case *slack.RTMError:
-			log.Printf("Error: %s\n", ev.Error())
+func (b *Bot) SendMessage(text string, channel string) {
+	b.backend.SendMessage(text, channel)
+}
 
-		case *slack.InvalidAuthEvent:
-			log.Printf("Invalid credentials\n")
-			break Loop
+func (b *Bot) Listen() {
+	b.backend.Listen(b)
+}
 
-		default:
-			// log.Printf("Unexpected: %v\n", msg.Data)
-		}
-	}
+// NewTestBot returns a bot for testing
+func NewTestBot() (*Bot, error) {
+	backend := &SlackBotBackend{}
+	return NewBot(NewConfig(true, false), "testbot", "", backend), nil
 }
 
-// SlackBlockQuote returns the string block-quoted
-func SlackBlockQuote(s string) string {
+// BlockQuote returns the string block-quoted
+func BlockQuote(s string) string {
 	if !strings.HasSuffix(s, "\n") {
 		s += "\n"
 	}

cli/cli.go

@@ -42,7 +42,7 @@ func Parse(app *kingpin.Application, args []string, stringBuffer *bytes.Buffer)
 	}
 
 	if stringBuffer.Len() > 0 {
-		return "", slackbot.SlackBlockQuote(stringBuffer.String()), nil
+		return "", slackbot.BlockQuote(stringBuffer.String()), nil
 	}
 
 	return cmd, "", err

examplebot/extension.go

@@ -14,7 +14,7 @@ import (
 
 type extension struct{}
 
-func (e *extension) Run(bot slackbot.Bot, channel string, args []string) (string, error) {
+func (e *extension) Run(bot *slackbot.Bot, channel string, args []string) (string, error) {
 	app := kingpin.New("examplebot", "Kingpin extension")
 	app.Terminate(nil)
 	stringBuffer := new(bytes.Buffer)
@@ -39,7 +39,7 @@ func (e *extension) Run(bot slackbot.Bot, channel string, args []string) (string
 	return cmd, nil
 }
 
-func (e *extension) Help(bot slackbot.Bot) string {
+func (e *extension) Help(bot *slackbot.Bot) string {
 	out, err := e.Run(bot, "", nil)
 	if err != nil {
 		return fmt.Sprintf("Error getting help: %s", err)

examplebot/main.go

@@ -13,10 +13,11 @@ type runner struct{}
 
 func main() {
 	config := slackbot.NewConfig(false, false)
-	bot, err := slackbot.NewBot(slackbot.GetTokenFromEnv(), "examplebot", "", config)
+	backend, err := slackbot.NewSlackBotBackend(slackbot.GetTokenFromEnv())
 	if err != nil {
 		log.Fatal(err)
 	}
+	bot := slackbot.NewBot(config, "examplebot", "", backend)
 
 	// Command that runs and shows date
 	bot.AddCommand("date", slackbot.NewExecCommand("/bin/date", nil, true, "Show the current date", config))

hybrid.go

@@ -0,0 +1,55 @@
+package slackbot
+
+import (
+	"sync"
+)
+
+type hybridRunner struct {
+	runner  BotCommandRunner
+	channel string
+}
+
+func newHybridRunner(runner BotCommandRunner, channel string) *hybridRunner {
+	return &hybridRunner{
+		runner:  runner,
+		channel: channel,
+	}
+}
+
+func (r *hybridRunner) RunCommand(args []string, channel string) error {
+	return r.runner.RunCommand(args, r.channel)
+
+}
+
+type HybridBackendMember struct {
+	Backend BotBackend
+	Channel string
+}
+
+type HybridBackend struct {
+	backends []HybridBackendMember
+}
+
+func NewHybridBackend(backends ...HybridBackendMember) *HybridBackend {
+	return &HybridBackend{
+		backends: backends,
+	}
+}
+
+func (b *HybridBackend) SendMessage(text string, channel string) {
+	for _, backend := range b.backends {
+		backend.Backend.SendMessage(text, backend.Channel)
+	}
+}
+
+func (b *HybridBackend) Listen(runner BotCommandRunner) {
+	var wg sync.WaitGroup
+	for _, backend := range b.backends {
+		wg.Add(1)
+		go func() {
+			backend.Backend.Listen(newHybridRunner(runner, backend.Channel))
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+}