Release v0.9.2

Fixes error message shown by tls: "either ServerName or InsecureSkipVerify must be specified in the tls.Config"

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,20 @@
+Please answer the following questions. 
+
+### Which version of matterbridge are you using?
+run ```matterbridge -version```
+
+### If you're having problems with mattermost please specify mattermost version. 
+
+
+### Please describe the expected behavior.
+
+
+### Please describe the actual behavior. 
+#### Use logs from running ```matterbridge -debug``` if possible.
+
+
+### Any steps to reproduce the behavior?
+
+
+### Please add your configuration file 
+#### (be sure to exclude or anonymize private data (tokens/passwords))

Dockerfile

@@ -2,10 +2,10 @@ FROM alpine:edge
 ENTRYPOINT ["/bin/matterbridge"]
 
 COPY . /go/src/github.com/42wim/matterbridge
-RUN apk update && apk add go git \
+RUN apk update && apk add go git gcc musl-dev ca-certificates \
         && cd /go/src/github.com/42wim/matterbridge \
         && export GOPATH=/go \
         && go get \
         && go build -o /bin/matterbridge \
         && rm -rf /go \
-        && apk del --purge git go
+        && apk del --purge git go gcc musl-dev

README-0.6.md

@@ -0,0 +1,115 @@
+# matterbridge
+
+Simple bridge between mattermost, IRC, XMPP, Gitter and Slack
+
+* Relays public channel messages between mattermost, IRC, XMPP, Gitter and Slack. Pick and mix.
+* Supports multiple channels.
+* Matterbridge can also work with private groups on your mattermost.
+
+Look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for documentation and an example.
+
+## Changelog
+Since v0.6.1 support for XMPP, Gitter and Slack is added. More details in [changelog.md] (https://github.com/42wim/matterbridge/blob/master/changelog.md)
+
+## Requirements:
+Accounts to one of the supported bridges
+* [Mattermost] (https://github.com/mattermost/platform/)
+* [IRC] (http://www.mirc.com/servers.html)
+* [XMPP] (https://jabber.org)
+* [Gitter] (https://gitter.im)
+* [Slack] (https://www.slack.com)
+
+## binaries
+Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
+* For use with mattermost 3.3.0+ [v0.6.1](https://github.com/42wim/matterircd/releases/tag/v0.6.1)
+* For use with mattermost 3.0.0-3.2.0 [v0.5.0](https://github.com/42wim/matterircd/releases/tag/v0.5.0)
+
+
+## Docker
+Create your matterbridge.conf file locally eg in ```/tmp/matterbridge.conf```
+
+```
+docker run -ti -v /tmp/matterbridge.conf:/matterbridge.conf 42wim/matterbridge:0.6.1
+```
+
+## Compatibility
+### Mattermost 
+* Matterbridge v0.6.1 works with mattermost 3.3.0 and higher [3.3.0 release](https://github.com/mattermost/platform/releases/tag/v3.3.0)
+* Matterbridge v0.5.0 works with mattermost 3.0.0 - 3.2.0 [3.2.0 release](https://github.com/mattermost/platform/releases/tag/v3.2.0)
+
+
+#### Webhooks version
+* Configured incoming/outgoing [webhooks](https://www.mattermost.org/webhooks/) on your mattermost instance.
+
+#### Plus (API) version
+* A dedicated user(bot) on your mattermost instance.
+
+
+## building
+Go 1.6+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)
+
+```
+cd $GOPATH
+go get github.com/42wim/matterbridge
+```
+
+You should now have matterbridge binary in the bin directory:
+
+```
+$ ls bin/
+matterbridge
+```
+
+## running
+1) Copy the matterbridge.conf.sample to matterbridge.conf in the same directory as the matterbridge binary.  
+2) Edit matterbridge.conf with the settings for your environment. See below for more config information.  
+3) Now you can run matterbridge. 
+
+```
+Usage of ./matterbridge:
+  -conf string
+        config file (default "matterbridge.conf")
+  -debug
+        enable debug
+  -plus
+        running using API instead of webhooks (deprecated, set Plus flag in [general] config)
+  -version
+        show version
+```
+
+## config
+### matterbridge
+matterbridge looks for matterbridge.conf in current directory. (use -conf to specify another file)
+
+Look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for an example.
+
+### mattermost
+#### webhooks version
+You'll have to configure the incoming and outgoing webhooks. 
+
+* incoming webhooks
+Go to "account settings" - integrations - "incoming webhooks".  
+Choose a channel at "Add a new incoming webhook", this will create a webhook URL right below.  
+This URL should be set in the matterbridge.conf in the [mattermost] section (see above)  
+
+* outgoing webhooks
+Go to "account settings" - integrations - "outgoing webhooks".  
+Choose a channel (the same as the one from incoming webhooks) and fill in the address and port of the server matterbridge will run on.  
+
+e.g. http://192.168.1.1:9999 (192.168.1.1:9999 is the BindAddress specified in [mattermost] section of matterbridge.conf)
+
+#### plus version
+You'll have to create a new dedicated user on your mattermost instance.
+Specify the login and password in [mattermost] section of matterbridge.conf
+
+## FAQ
+Please look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for more information first. 
+### Mattermost doesn't show the IRC nicks
+If you're running the webhooks version, this can be fixed by either:
+* enabling "override usernames". See [mattermost documentation](http://docs.mattermost.com/developer/webhooks-incoming.html#enabling-incoming-webhooks)
+* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.conf.
+
+If you're running the plus version you'll need to:
+* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.conf.
+
+Also look at the ```RemoteNickFormat``` setting.

README.md

@@ -1,25 +1,55 @@
 # matterbridge
+![matterbridge.gif](https://s15.postimg.org/qpjhp6y3f/matterbridge.gif)
 
-Simple bridge between mattermost and IRC. 
+Simple bridge between mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, Rocket.Chat and Hipchat(via xmpp).
 
-* Relays public channel messages between mattermost and IRC.
+* Relays public channel messages between multiple mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, Rocket.Chat and Hipchat (via xmpp). Pick and mix.
-* Supports multiple mattermost and irc channels.
+* Supports multiple channels.
-* Matterbridge -plus also works with private groups on your mattermost.
+* Matterbridge can also work with private groups on your mattermost.
+* Allow for bridging the same bridges, which means you can eg bridge between multiple mattermosts.
+* The bridge is now a gateway which has support multiple in and out bridges. (and supports multiple gateways).
 
-This project has now [matterbridge-plus](https://github.com/42wim/matterbridge-plus/) merged in. 
+Look at [matterbridge.toml.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for documentation and an example.
-Breaking changes for matterbridge can be found in [migration](https://github.com/42wim/matterbridge/blob/master/migration.md)
+Look at [matterbridge.toml.simple] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.simple) for a simple example.
 
-## Requirements:
-* [Mattermost] (https://github.com/mattermost/platform/) 3.x (stable, not a dev build)
 
-### Webhooks version
+## Changelog
-* Configured incoming/outgoing [webhooks](https://www.mattermost.org/webhooks/) on your mattermost instance.
+Since v0.7.0 the configuration has changed. More details in [changelog.md] (https://github.com/42wim/matterbridge/blob/master/changelog.md)
 
-### Plus (API) version
+## Requirements
-* A dedicated user(bot) on your mattermost instance.
+Accounts to one of the supported bridges
+* [Mattermost] (https://github.com/mattermost/platform/)
+* [IRC] (http://www.mirc.com/servers.html)
+* [XMPP] (https://jabber.org)
+* [Gitter] (https://gitter.im)
+* [Slack] (https://slack.com)
+* [Discord] (https://discordapp.com)
+* [Telegram] (https://telegram.org)
+* [Hipchat] (https://www.hipchat.com)
+* [Rocket.chat] (https://rocket.chat)
+
+## Docker
+Create your matterbridge.toml file locally eg in ```/tmp/matterbridge.toml```
+```
+docker run -ti -v /tmp/matterbridge.toml:/matterbridge.toml 42wim/matterbridge
+```
 
 ## binaries
-Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/tag/v0.5-beta2)
+Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
+* For use with mattermost 3.5.x - 3.6.0 [v0.9.2](https://github.com/42wim/matterircd/releases/tag/v0.9.2)
+* For use with mattermost 3.3.0 - 3.4.0 [v0.7.1](https://github.com/42wim/matterircd/releases/tag/v0.7.1)
+
+## Compatibility
+### Mattermost 
+* Matterbridge v0.9.2 works with mattermost 3.5.x - 3.6.0 [3.6.0 release](https://github.com/mattermost/platform/releases/tag/v3.6.0)
+* Matterbridge v0.7.1 works with mattermost 3.3.0 - 3.4.0 [3.4.0 release](https://github.com/mattermost/platform/releases/tag/v3.4.0)
+
+#### Webhooks version
+* Configured incoming/outgoing [webhooks](https://www.mattermost.org/webhooks/) on your mattermost instance.
+
+#### API version
+* A dedicated user(bot) on your mattermost instance.
+
 
 ## building
 Go 1.6+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)
@@ -44,20 +74,18 @@ matterbridge
 ```
 Usage of ./matterbridge:
   -conf string
-        config file (default "matterbridge.conf")
+        config file (default "matterbridge.toml")
   -debug
         enable debug
-  -plus
-        running using API instead of webhooks
   -version
         show version
 ```
 
 ## config
 ### matterbridge
-matterbridge looks for matterbridge.conf in current directory. (use -conf to specify another file)
+matterbridge looks for matterbridge.toml in current directory. (use -conf to specify another file)
 
-Look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for an example.
+Look at [matterbridge.toml.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for an example.
 
 ### mattermost
 #### webhooks version
@@ -74,18 +102,14 @@ Choose a channel (the same as the one from incoming webhooks) and fill in the ad
 
 e.g. http://192.168.1.1:9999 (192.168.1.1:9999 is the BindAddress specified in [mattermost] section of matterbridge.conf)
 
-#### plus version
-You'll have to create a new dedicated user on your mattermost instance.
-Specify the login and password in [mattermost] section of matterbridge.conf
-
 ## FAQ
-Please look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for more information first. 
+Please look at [matterbridge.toml.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for more information first. 
 ### Mattermost doesn't show the IRC nicks
 If you're running the webhooks version, this can be fixed by either:
 * enabling "override usernames". See [mattermost documentation](http://docs.mattermost.com/developer/webhooks-incoming.html#enabling-incoming-webhooks)
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.conf.
+* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.toml.
 
 If you're running the plus version you'll need to:
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.conf.
+* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.toml.
 
 Also look at the ```RemoteNickFormat``` setting.

bridge/bridge.go

@@ -1,407 +1,68 @@
 package bridge
 
 import (
-	"crypto/tls"
+	"github.com/42wim/matterbridge/bridge/config"
-	"github.com/42wim/matterbridge/matterclient"
+	"github.com/42wim/matterbridge/bridge/discord"
-	"github.com/42wim/matterbridge/matterhook"
+	"github.com/42wim/matterbridge/bridge/gitter"
-	log "github.com/Sirupsen/logrus"
+	"github.com/42wim/matterbridge/bridge/irc"
-	"github.com/peterhellberg/giphy"
+	"github.com/42wim/matterbridge/bridge/mattermost"
-	ircm "github.com/sorcix/irc"
+	"github.com/42wim/matterbridge/bridge/rocketchat"
-	"github.com/thoj/go-ircevent"
+	"github.com/42wim/matterbridge/bridge/slack"
-	"regexp"
+	"github.com/42wim/matterbridge/bridge/telegram"
-	"sort"
+	"github.com/42wim/matterbridge/bridge/xmpp"
-	"strconv"
 	"strings"
-	"time"
 )
 
-//type Bridge struct {
+type Bridger interface {
-type MMhook struct {
+	Send(msg config.Message) error
-	mh *matterhook.Client
+	Connect() error
-}
+	JoinChannel(channel string) error
-
-type MMapi struct {
-	mc            *matterclient.MMClient
-	mmMap         map[string]string
-	mmIgnoreNicks []string
-}
-
-type MMirc struct {
-	i              *irc.Connection
-	ircNick        string
-	ircMap         map[string]string
-	names          map[string][]string
-	ircIgnoreNicks []string
-}
-
-type MMMessage struct {
-	Text     string
-	Channel  string
-	Username string
 }
 
 type Bridge struct {
-	MMhook
+	Config config.Protocol
-	MMapi
+	Bridger
-	MMirc
+	Name     string
-	*Config
+	Account  string
-	kind string
+	Protocol string
 }
 
-type FancyLog struct {
+func New(cfg *config.Config, bridge *config.Bridge, c chan config.Message) *Bridge {
-	irc *log.Entry
+	b := new(Bridge)
-	mm  *log.Entry
+	accInfo := strings.Split(bridge.Account, ".")
-}
+	protocol := accInfo[0]
+	name := accInfo[1]
+	b.Name = name
+	b.Protocol = protocol
+	b.Account = bridge.Account
 
-var flog FancyLog
+	// override config from environment
-
+	config.OverrideCfgFromEnv(cfg, protocol, name)
-const Legacy = "legacy"
+	switch protocol {
-
+	case "mattermost":
-func initFLog() {
+		b.Config = cfg.Mattermost[name]
-	flog.irc = log.WithFields(log.Fields{"module": "irc"})
+		b.Bridger = bmattermost.New(cfg.Mattermost[name], bridge.Account, c)
-	flog.mm = log.WithFields(log.Fields{"module": "mattermost"})
+	case "irc":
-}
+		b.Config = cfg.IRC[name]
-
+		b.Bridger = birc.New(cfg.IRC[name], bridge.Account, c)
-func NewBridge(name string, config *Config, kind string) *Bridge {
+	case "gitter":
-	initFLog()
+		b.Config = cfg.Gitter[name]
-	b := &Bridge{}
+		b.Bridger = bgitter.New(cfg.Gitter[name], bridge.Account, c)
-	b.Config = config
+	case "slack":
-	b.kind = kind
+		b.Config = cfg.Slack[name]
-	b.ircNick = b.Config.IRC.Nick
+		b.Bridger = bslack.New(cfg.Slack[name], bridge.Account, c)
-	b.ircMap = make(map[string]string)
+	case "xmpp":
-	b.mmMap = make(map[string]string)
+		b.Config = cfg.Xmpp[name]
-	b.MMirc.names = make(map[string][]string)
+		b.Bridger = bxmpp.New(cfg.Xmpp[name], bridge.Account, c)
-	b.ircIgnoreNicks = strings.Fields(b.Config.IRC.IgnoreNicks)
+	case "discord":
-	b.mmIgnoreNicks = strings.Fields(b.Config.Mattermost.IgnoreNicks)
+		b.Config = cfg.Discord[name]
-	for _, val := range b.Config.Channel {
+		b.Bridger = bdiscord.New(cfg.Discord[name], bridge.Account, c)
-		b.ircMap[val.IRC] = val.Mattermost
+	case "telegram":
-		b.mmMap[val.Mattermost] = val.IRC
+		b.Config = cfg.Telegram[name]
+		b.Bridger = btelegram.New(cfg.Telegram[name], bridge.Account, c)
+	case "rocketchat":
+		b.Config = cfg.Rocketchat[name]
+		b.Bridger = brocketchat.New(cfg.Rocketchat[name], bridge.Account, c)
 	}
-	if kind == Legacy {
-		b.mh = matterhook.New(b.Config.Mattermost.URL,
-			matterhook.Config{InsecureSkipVerify: b.Config.Mattermost.SkipTLSVerify,
-				BindAddress: b.Config.Mattermost.BindAddress})
-	} else {
-		b.mc = matterclient.New(b.Config.Mattermost.Login, b.Config.Mattermost.Password,
-			b.Config.Mattermost.Team, b.Config.Mattermost.Server)
-		b.mc.SkipTLSVerify = b.Config.Mattermost.SkipTLSVerify
-		b.mc.NoTLS = b.Config.Mattermost.NoTLS
-		flog.mm.Infof("Trying login %s (team: %s) on %s", b.Config.Mattermost.Login, b.Config.Mattermost.Team, b.Config.Mattermost.Server)
-		err := b.mc.Login()
-		if err != nil {
-			flog.mm.Fatal("Can not connect", err)
-		}
-		flog.mm.Info("Login ok")
-		b.mc.JoinChannel(b.Config.Mattermost.Channel)
-		for _, val := range b.Config.Channel {
-			b.mc.JoinChannel(val.Mattermost)
-		}
-		go b.mc.WsReceiver()
-	}
-	flog.irc.Info("Trying IRC connection")
-	b.i = b.createIRC(name)
-	flog.irc.Info("Connection succeeded")
-	go b.handleMatter()
 	return b
 }
-
-func (b *Bridge) createIRC(name string) *irc.Connection {
-	i := irc.IRC(b.Config.IRC.Nick, b.Config.IRC.Nick)
-	i.UseTLS = b.Config.IRC.UseTLS
-	i.UseSASL = b.Config.IRC.UseSASL
-	i.SASLLogin = b.Config.IRC.NickServNick
-	i.SASLPassword = b.Config.IRC.NickServPassword
-	i.TLSConfig = &tls.Config{InsecureSkipVerify: b.Config.IRC.SkipTLSVerify}
-	if b.Config.IRC.Password != "" {
-		i.Password = b.Config.IRC.Password
-	}
-	i.AddCallback(ircm.RPL_WELCOME, b.handleNewConnection)
-	err := i.Connect(b.Config.IRC.Server)
-	if err != nil {
-		flog.irc.Fatal(err)
-	}
-	return i
-}
-
-func (b *Bridge) handleNewConnection(event *irc.Event) {
-	flog.irc.Info("Registering callbacks")
-	i := b.i
-	b.ircNick = event.Arguments[0]
-	i.AddCallback("PRIVMSG", b.handlePrivMsg)
-	i.AddCallback("CTCP_ACTION", b.handlePrivMsg)
-	i.AddCallback(ircm.RPL_ENDOFNAMES, b.endNames)
-	i.AddCallback(ircm.RPL_NAMREPLY, b.storeNames)
-	i.AddCallback(ircm.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
-	i.AddCallback(ircm.NOTICE, b.handleNotice)
-	i.AddCallback(ircm.RPL_MYINFO, func(e *irc.Event) { flog.irc.Infof("%s: %s", e.Code, strings.Join(e.Arguments[1:], " ")) })
-	i.AddCallback("PING", func(e *irc.Event) {
-		i.SendRaw("PONG :" + e.Message())
-		flog.irc.Debugf("PING/PONG")
-	})
-	if b.Config.Mattermost.ShowJoinPart {
-		i.AddCallback("JOIN", b.handleJoinPart)
-		i.AddCallback("PART", b.handleJoinPart)
-	}
-	i.AddCallback("*", b.handleOther)
-	b.setupChannels()
-}
-
-func (b *Bridge) setupChannels() {
-	i := b.i
-	for _, val := range b.Config.Channel {
-		flog.irc.Infof("Joining %s as %s", val.IRC, b.ircNick)
-		i.Join(val.IRC)
-	}
-}
-
-func (b *Bridge) handleIrcBotCommand(event *irc.Event) bool {
-	parts := strings.Fields(event.Message())
-	exp, _ := regexp.Compile("[:,]+$")
-	channel := event.Arguments[0]
-	command := ""
-	if len(parts) == 2 {
-		command = parts[1]
-	}
-	if exp.ReplaceAllString(parts[0], "") == b.ircNick {
-		switch command {
-		case "users":
-			usernames := b.mc.UsernamesInChannel(b.getMMChannel(channel))
-			sort.Strings(usernames)
-			b.i.Privmsg(channel, "Users on Mattermost: "+strings.Join(usernames, ", "))
-		default:
-			b.i.Privmsg(channel, "Valid commands are: [users, help]")
-		}
-		return true
-	}
-	return false
-}
-
-func (b *Bridge) ircNickFormat(nick string) string {
-	if nick == b.ircNick {
-		return nick
-	}
-	if b.Config.Mattermost.RemoteNickFormat == nil {
-		return "irc-" + nick
-	}
-	return strings.Replace(*b.Config.Mattermost.RemoteNickFormat, "{NICK}", nick, -1)
-}
-
-func (b *Bridge) handlePrivMsg(event *irc.Event) {
-	flog.irc.Debugf("handlePrivMsg() %s %s", event.Nick, event.Message())
-	if b.ignoreMessage(event.Nick, event.Message(), "irc") {
-		return
-	}
-	if b.handleIrcBotCommand(event) {
-		return
-	}
-	msg := ""
-	if event.Code == "CTCP_ACTION" {
-		msg = event.Nick + " "
-	}
-	msg += event.Message()
-	b.Send(b.ircNickFormat(event.Nick), msg, b.getMMChannel(event.Arguments[0]))
-}
-
-func (b *Bridge) handleJoinPart(event *irc.Event) {
-	b.Send(b.ircNick, b.ircNickFormat(event.Nick)+" "+strings.ToLower(event.Code)+"s "+event.Message(), b.getMMChannel(event.Arguments[0]))
-}
-
-func (b *Bridge) handleNotice(event *irc.Event) {
-	if strings.Contains(event.Message(), "This nickname is registered") {
-		b.i.Privmsg(b.Config.IRC.NickServNick, "IDENTIFY "+b.Config.IRC.NickServPassword)
-	}
-}
-
-func (b *Bridge) nicksPerRow() int {
-	if b.Config.Mattermost.NicksPerRow < 1 {
-		return 4
-	}
-	return b.Config.Mattermost.NicksPerRow
-}
-
-func (b *Bridge) formatnicks(nicks []string, continued bool) string {
-	switch b.Config.Mattermost.NickFormatter {
-	case "table":
-		return tableformatter(nicks, b.nicksPerRow(), continued)
-	default:
-		return plainformatter(nicks, b.nicksPerRow())
-	}
-}
-
-func (b *Bridge) storeNames(event *irc.Event) {
-	channel := event.Arguments[2]
-	b.MMirc.names[channel] = append(
-		b.MMirc.names[channel],
-		strings.Split(strings.TrimSpace(event.Message()), " ")...)
-}
-
-func (b *Bridge) endNames(event *irc.Event) {
-	channel := event.Arguments[1]
-	sort.Strings(b.MMirc.names[channel])
-	maxNamesPerPost := (300 / b.nicksPerRow()) * b.nicksPerRow()
-	continued := false
-	for len(b.MMirc.names[channel]) > maxNamesPerPost {
-		b.Send(
-			b.ircNick,
-			b.formatnicks(b.MMirc.names[channel][0:maxNamesPerPost], continued),
-			b.getMMChannel(channel))
-		b.MMirc.names[channel] = b.MMirc.names[channel][maxNamesPerPost:]
-		continued = true
-	}
-	b.Send(b.ircNick, b.formatnicks(b.MMirc.names[channel], continued), b.getMMChannel(channel))
-	b.MMirc.names[channel] = nil
-}
-
-func (b *Bridge) handleTopicWhoTime(event *irc.Event) {
-	parts := strings.Split(event.Arguments[2], "!")
-	t, err := strconv.ParseInt(event.Arguments[3], 10, 64)
-	if err != nil {
-		flog.irc.Errorf("Invalid time stamp: %s", event.Arguments[3])
-	}
-	user := parts[0]
-	if len(parts) > 1 {
-		user += " [" + parts[1] + "]"
-	}
-	flog.irc.Infof("%s: Topic set by %s [%s]", event.Code, user, time.Unix(t, 0))
-}
-
-func (b *Bridge) handleOther(event *irc.Event) {
-	flog.irc.Debugf("%#v", event)
-}
-
-func (b *Bridge) Send(nick string, message string, channel string) error {
-	return b.SendType(nick, message, channel, "")
-}
-
-func (b *Bridge) SendType(nick string, message string, channel string, mtype string) error {
-	if b.Config.Mattermost.PrefixMessagesWithNick {
-		if IsMarkup(message) {
-			message = nick + "\n\n" + message
-		} else {
-			message = nick + " " + message
-		}
-	}
-	if b.kind == Legacy {
-		matterMessage := matterhook.OMessage{IconURL: b.Config.Mattermost.IconURL}
-		matterMessage.Channel = channel
-		matterMessage.UserName = nick
-		matterMessage.Type = mtype
-		matterMessage.Text = message
-		err := b.mh.Send(matterMessage)
-		if err != nil {
-			flog.mm.Info(err)
-			return err
-		}
-		flog.mm.Debug("->mattermost channel: ", channel, " ", message)
-		return nil
-	}
-	flog.mm.Debug("->mattermost channel: ", channel, " ", message)
-	b.mc.PostMessage(channel, message)
-	return nil
-}
-
-func (b *Bridge) handleMatterHook(mchan chan *MMMessage) {
-	for {
-		message := b.mh.Receive()
-		flog.mm.Debugf("receiving from matterhook %#v", message)
-		m := &MMMessage{}
-		m.Username = message.UserName
-		m.Text = message.Text
-		m.Channel = message.ChannelName
-		mchan <- m
-	}
-}
-
-func (b *Bridge) handleMatterClient(mchan chan *MMMessage) {
-	for message := range b.mc.MessageChan {
-		// do not post our own messages back to irc
-		if message.Raw.Action == "posted" && b.mc.User.Username != message.Username {
-			flog.mm.Debugf("receiving from matterclient %#v", message)
-			m := &MMMessage{}
-			m.Username = message.Username
-			m.Channel = message.Channel
-			m.Text = message.Text
-			mchan <- m
-		}
-	}
-}
-
-func (b *Bridge) handleMatter() {
-	flog.mm.Infof("Choosing Mattermost connection type %s", b.kind)
-	mchan := make(chan *MMMessage)
-	if b.kind == Legacy {
-		go b.handleMatterHook(mchan)
-	} else {
-		go b.handleMatterClient(mchan)
-	}
-	flog.mm.Info("Start listening for Mattermost messages")
-	for message := range mchan {
-		var username string
-		if b.ignoreMessage(message.Username, message.Text, "mattermost") {
-			continue
-		}
-		username = message.Username + ": "
-		if b.Config.IRC.RemoteNickFormat != "" {
-			username = strings.Replace(b.Config.IRC.RemoteNickFormat, "{NICK}", message.Username, -1)
-		}
-		cmds := strings.Fields(message.Text)
-		// empty message
-		if len(cmds) == 0 {
-			continue
-		}
-		cmd := cmds[0]
-		switch cmd {
-		case "!users":
-			flog.mm.Info("Received !users from ", message.Username)
-			b.i.SendRaw("NAMES " + b.getIRCChannel(message.Channel))
-			continue
-		case "!gif":
-			message.Text = b.giphyRandom(strings.Fields(strings.Replace(message.Text, "!gif ", "", 1)))
-			b.Send(b.ircNick, message.Text, b.getIRCChannel(message.Channel))
-			continue
-		}
-		texts := strings.Split(message.Text, "\n")
-		for _, text := range texts {
-			flog.mm.Debug("Sending message from " + message.Username + " to " + message.Channel)
-			b.i.Privmsg(b.getIRCChannel(message.Channel), username+text)
-		}
-	}
-}
-
-func (b *Bridge) giphyRandom(query []string) string {
-	g := giphy.DefaultClient
-	if b.Config.General.GiphyAPIKey != "" {
-		g.APIKey = b.Config.General.GiphyAPIKey
-	}
-	res, err := g.Random(query)
-	if err != nil {
-		return "error"
-	}
-	return res.Data.FixedHeightDownsampledURL
-}
-
-func (b *Bridge) getMMChannel(ircChannel string) string {
-	mmChannel := b.ircMap[ircChannel]
-	if b.kind == Legacy {
-		return mmChannel
-	}
-	return b.mc.GetChannelId(mmChannel, "")
-}
-
-func (b *Bridge) getIRCChannel(mmChannel string) string {
-	return b.mmMap[mmChannel]
-}
-
-func (b *Bridge) ignoreMessage(nick string, message string, protocol string) bool {
-	var ignoreNicks = b.mmIgnoreNicks
-	if protocol == "irc" {
-		ignoreNicks = b.ircIgnoreNicks
-	}
-	// should we discard messages ?
-	for _, entry := range ignoreNicks {
-		if nick == entry {
-			return true
-		}
-	}
-	return false
-}

bridge/config.go

@@ -1,61 +0,0 @@
-package bridge
-
-import (
-	"gopkg.in/gcfg.v1"
-	"io/ioutil"
-	"log"
-)
-
-type Config struct {
-	IRC struct {
-		UseTLS           bool
-		UseSASL          bool
-		SkipTLSVerify    bool
-		Server           string
-		Nick             string
-		Password         string
-		Channel          string
-		NickServNick     string
-		NickServPassword string
-		RemoteNickFormat string
-		IgnoreNicks      string
-	}
-	Mattermost struct {
-		URL                    string
-		ShowJoinPart           bool
-		IconURL                string
-		SkipTLSVerify          bool
-		BindAddress            string
-		Channel                string
-		PrefixMessagesWithNick bool
-		NicksPerRow            int
-		NickFormatter          string
-		Server                 string
-		Team                   string
-		Login                  string
-		Password               string
-		RemoteNickFormat       *string
-		IgnoreNicks            string
-		NoTLS                  bool
-	}
-	Channel map[string]*struct {
-		IRC        string
-		Mattermost string
-	}
-	General struct {
-		GiphyAPIKey string
-	}
-}
-
-func NewConfig(cfgfile string) *Config {
-	var cfg Config
-	content, err := ioutil.ReadFile(cfgfile)
-	if err != nil {
-		log.Fatal(err)
-	}
-	err = gcfg.ReadStringInto(&cfg, string(content))
-	if err != nil {
-		log.Fatal("Failed to parse "+cfgfile+":", err)
-	}
-	return &cfg
-}

bridge/config/config.go

@@ -0,0 +1,148 @@
+package config
+
+import (
+	"github.com/BurntSushi/toml"
+	"log"
+	"os"
+	"reflect"
+	"strings"
+)
+
+const (
+	EVENT_JOIN_LEAVE = "join_leave"
+)
+
+type Message struct {
+	Text     string
+	Channel  string
+	Username string
+	Avatar   string
+	Account  string
+	Event    string
+}
+
+type Protocol struct {
+	BindAddress            string // mattermost, slack
+	IconURL                string // mattermost, slack
+	IgnoreNicks            string // all protocols
+	Jid                    string // xmpp
+	Login                  string // mattermost
+	Muc                    string // xmpp
+	Name                   string // all protocols
+	Nick                   string // all protocols
+	NickFormatter          string // mattermost, slack
+	NickServNick           string // IRC
+	NickServPassword       string // IRC
+	NicksPerRow            int    // mattermost, slack
+	NoTLS                  bool   // mattermost
+	Password               string // IRC,mattermost,XMPP
+	PrefixMessagesWithNick bool   // mattemost, slack
+	Protocol               string //all protocols
+	MessageQueue           int    // IRC, size of message queue for flood control
+	MessageDelay           int    // IRC, time in millisecond to wait between messages
+	RemoteNickFormat       string // all protocols
+	Server                 string // IRC,mattermost,XMPP,discord
+	ShowJoinPart           bool   // all protocols
+	SkipTLSVerify          bool   // IRC, mattermost
+	Team                   string // mattermost
+	Token                  string // gitter, slack, discord
+	URL                    string // mattermost, slack
+	UseAPI                 bool   // mattermost, slack
+	UseSASL                bool   // IRC
+	UseTLS                 bool   // IRC
+}
+
+type ChannelOptions struct {
+	Key string // irc
+}
+
+type Bridge struct {
+	Account string
+	Channel string
+	Options ChannelOptions
+}
+
+type Gateway struct {
+	Name   string
+	Enable bool
+	In     []Bridge
+	Out    []Bridge
+	InOut  []Bridge
+}
+
+type SameChannelGateway struct {
+	Name     string
+	Enable   bool
+	Channels []string
+	Accounts []string
+}
+
+type Config struct {
+	IRC                map[string]Protocol
+	Mattermost         map[string]Protocol
+	Slack              map[string]Protocol
+	Gitter             map[string]Protocol
+	Xmpp               map[string]Protocol
+	Discord            map[string]Protocol
+	Telegram           map[string]Protocol
+	Rocketchat         map[string]Protocol
+	General            Protocol
+	Gateway            []Gateway
+	SameChannelGateway []SameChannelGateway
+}
+
+func NewConfig(cfgfile string) *Config {
+	var cfg Config
+	if _, err := toml.DecodeFile(cfgfile, &cfg); err != nil {
+		log.Fatal(err)
+	}
+	return &cfg
+}
+
+func OverrideCfgFromEnv(cfg *Config, protocol string, account string) {
+	var protoCfg Protocol
+	val := reflect.ValueOf(cfg).Elem()
+	// loop over the Config struct
+	for i := 0; i < val.NumField(); i++ {
+		typeField := val.Type().Field(i)
+		// look for the protocol map (both lowercase)
+		if strings.ToLower(typeField.Name) == protocol {
+			// get the Protocol struct from the map
+			data := val.Field(i).MapIndex(reflect.ValueOf(account))
+			protoCfg = data.Interface().(Protocol)
+			protoStruct := reflect.ValueOf(&protoCfg).Elem()
+			// loop over the found protocol struct
+			for i := 0; i < protoStruct.NumField(); i++ {
+				typeField := protoStruct.Type().Field(i)
+				// build our environment key (eg MATTERBRIDGE_MATTERMOST_WORK_LOGIN)
+				key := "matterbridge_" + protocol + "_" + account + "_" + typeField.Name
+				key = strings.ToUpper(key)
+				// search the environment
+				res := os.Getenv(key)
+				// if it exists and the current field is a string
+				// then update the current field
+				if res != "" {
+					fieldVal := protoStruct.Field(i)
+					if fieldVal.Kind() == reflect.String {
+						log.Printf("config: overriding %s from env with %s\n", key, res)
+						fieldVal.Set(reflect.ValueOf(res))
+					}
+				}
+			}
+			// update the map with the modified Protocol (cfg.Protocol[account] = Protocol)
+			val.Field(i).SetMapIndex(reflect.ValueOf(account), reflect.ValueOf(protoCfg))
+			break
+		}
+	}
+}
+
+func GetIconURL(msg *Message, cfg *Protocol) string {
+	iconURL := cfg.IconURL
+	info := strings.Split(msg.Account, ".")
+	protocol := info[0]
+	name := info[1]
+	iconURL = strings.Replace(iconURL, "{NICK}", msg.Username, -1)
+	iconURL = strings.Replace(iconURL, "{BRIDGE}", name, -1)
+	iconURL = strings.Replace(iconURL, "{PROTOCOL}", protocol, -1)
+	return iconURL
+}

bridge/discord/discord.go

@@ -0,0 +1,137 @@
+package bdiscord
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/Sirupsen/logrus"
+	"github.com/bwmarrin/discordgo"
+	"strings"
+)
+
+type bdiscord struct {
+	c            *discordgo.Session
+	Config       *config.Protocol
+	Remote       chan config.Message
+	Account      string
+	Channels     []*discordgo.Channel
+	Nick         string
+	UseChannelID bool
+}
+
+var flog *log.Entry
+var protocol = "discord"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *bdiscord {
+	b := &bdiscord{}
+	b.Config = &cfg
+	b.Remote = c
+	b.Account = account
+	return b
+}
+
+func (b *bdiscord) Connect() error {
+	var err error
+	flog.Info("Connecting")
+	if !strings.HasPrefix(b.Config.Token, "Bot ") {
+		b.Config.Token = "Bot " + b.Config.Token
+	}
+	b.c, err = discordgo.New(b.Config.Token)
+	if err != nil {
+		flog.Debugf("%#v", err)
+		return err
+	}
+	flog.Info("Connection succeeded")
+	b.c.AddHandler(b.messageCreate)
+	err = b.c.Open()
+	if err != nil {
+		flog.Debugf("%#v", err)
+		return err
+	}
+	guilds, err := b.c.UserGuilds()
+	if err != nil {
+		flog.Debugf("%#v", err)
+		return err
+	}
+	userinfo, err := b.c.User("@me")
+	if err != nil {
+		flog.Debugf("%#v", err)
+		return err
+	}
+	b.Nick = userinfo.Username
+	for _, guild := range guilds {
+		if guild.Name == b.Config.Server {
+			b.Channels, err = b.c.GuildChannels(guild.ID)
+			if err != nil {
+				flog.Debugf("%#v", err)
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (b *bdiscord) JoinChannel(channel string) error {
+	idcheck := strings.Split(channel, "ID:")
+	if len(idcheck) > 1 {
+		b.UseChannelID = true
+	}
+	return nil
+}
+
+func (b *bdiscord) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	channelID := b.getChannelID(msg.Channel)
+	if channelID == "" {
+		flog.Errorf("Could not find channelID for %v", msg.Channel)
+		return nil
+	}
+	b.c.ChannelMessageSend(channelID, msg.Username+msg.Text)
+	return nil
+}
+
+func (b *bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+	// not relay our own messages
+	if m.Author.Username == b.Nick {
+		return
+	}
+	if len(m.Attachments) > 0 {
+		for _, attach := range m.Attachments {
+			m.Content = m.Content + "\n" + attach.URL
+		}
+	}
+	if m.Content == "" {
+		return
+	}
+	flog.Debugf("Sending message from %s on %s to gateway", m.Author.Username, b.Account)
+	channelName := b.getChannelName(m.ChannelID)
+	if b.UseChannelID {
+		channelName = "ID:" + m.ChannelID
+	}
+	b.Remote <- config.Message{Username: m.Author.Username, Text: m.ContentWithMentionsReplaced(), Channel: channelName,
+		Account: b.Account, Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg"}
+}
+
+func (b *bdiscord) getChannelID(name string) string {
+	idcheck := strings.Split(name, "ID:")
+	if len(idcheck) > 1 {
+		return idcheck[1]
+	}
+	for _, channel := range b.Channels {
+		if channel.Name == name {
+			return channel.ID
+		}
+	}
+	return ""
+}
+
+func (b *bdiscord) getChannelName(id string) string {
+	for _, channel := range b.Channels {
+		if channel.ID == id {
+			return channel.Name
+		}
+	}
+	return ""
+}

bridge/gitter/gitter.go

@@ -0,0 +1,115 @@
+package bgitter
+
+import (
+	"github.com/42wim/go-gitter"
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/Sirupsen/logrus"
+	"strings"
+)
+
+type Bgitter struct {
+	c       *gitter.Gitter
+	Config  *config.Protocol
+	Remote  chan config.Message
+	Account string
+	Users   []gitter.User
+	Rooms   []gitter.Room
+}
+
+var flog *log.Entry
+var protocol = "gitter"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *Bgitter {
+	b := &Bgitter{}
+	b.Config = &cfg
+	b.Remote = c
+	b.Account = account
+	return b
+}
+
+func (b *Bgitter) Connect() error {
+	var err error
+	flog.Info("Connecting")
+	b.c = gitter.New(b.Config.Token)
+	_, err = b.c.GetUser()
+	if err != nil {
+		flog.Debugf("%#v", err)
+		return err
+	}
+	flog.Info("Connection succeeded")
+	b.Rooms, _ = b.c.GetRooms()
+	return nil
+}
+
+func (b *Bgitter) JoinChannel(channel string) error {
+	room := channel
+	roomID := b.getRoomID(room)
+	if roomID == "" {
+		return nil
+	}
+	user, err := b.c.GetUser()
+	if err != nil {
+		return err
+	}
+	_, err = b.c.JoinRoom(roomID, user.ID)
+	if err != nil {
+		return err
+	}
+	users, _ := b.c.GetUsersInRoom(roomID)
+	b.Users = append(b.Users, users...)
+	stream := b.c.Stream(roomID)
+	go b.c.Listen(stream)
+
+	go func(stream *gitter.Stream, room string) {
+		for event := range stream.Event {
+			switch ev := event.Data.(type) {
+			case *gitter.MessageReceived:
+				// check for ZWSP to see if it's not an echo
+				if !strings.HasSuffix(ev.Message.Text, "​") {
+					flog.Debugf("Sending message from %s on %s to gateway", ev.Message.From.Username, b.Account)
+					b.Remote <- config.Message{Username: ev.Message.From.Username, Text: ev.Message.Text, Channel: room,
+						Account: b.Account, Avatar: b.getAvatar(ev.Message.From.Username)}
+				}
+			case *gitter.GitterConnectionClosed:
+				flog.Errorf("connection with gitter closed for room %s", room)
+			}
+		}
+	}(stream, room)
+	return nil
+}
+
+func (b *Bgitter) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	roomID := b.getRoomID(msg.Channel)
+	if roomID == "" {
+		flog.Errorf("Could not find roomID for %v", msg.Channel)
+		return nil
+	}
+	// add ZWSP because gitter echoes our own messages
+	return b.c.SendMessage(roomID, msg.Username+msg.Text+" ​")
+}
+
+func (b *Bgitter) getRoomID(channel string) string {
+	for _, v := range b.Rooms {
+		if v.URI == channel {
+			return v.ID
+		}
+	}
+	return ""
+}
+
+func (b *Bgitter) getAvatar(user string) string {
+	var avatar string
+	if b.Users != nil {
+		for _, u := range b.Users {
+			if user == u.Username {
+				return u.AvatarURLSmall
+			}
+		}
+	}
+	return avatar
+}

bridge/irc/helper.go

@@ -1,4 +1,4 @@
-package bridge
+package birc
 
 import (
 	"strings"

bridge/irc/irc.go

@@ -0,0 +1,257 @@
+package birc
+
+import (
+	"crypto/tls"
+	"fmt"
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/Sirupsen/logrus"
+	ircm "github.com/sorcix/irc"
+	"github.com/thoj/go-ircevent"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Birc struct {
+	i         *irc.Connection
+	Nick      string
+	names     map[string][]string
+	Config    *config.Protocol
+	Remote    chan config.Message
+	connected chan struct{}
+	Local     chan config.Message // local queue for flood control
+	Account   string
+}
+
+var flog *log.Entry
+var protocol = "irc"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *Birc {
+	b := &Birc{}
+	b.Config = &cfg
+	b.Nick = b.Config.Nick
+	b.Remote = c
+	b.names = make(map[string][]string)
+	b.Account = account
+	b.connected = make(chan struct{})
+	if b.Config.MessageDelay == 0 {
+		b.Config.MessageDelay = 1300
+	}
+	if b.Config.MessageQueue == 0 {
+		b.Config.MessageQueue = 30
+	}
+	b.Local = make(chan config.Message, b.Config.MessageQueue+10)
+	return b
+}
+
+func (b *Birc) Command(msg *config.Message) string {
+	switch msg.Text {
+	case "!users":
+		b.i.AddCallback(ircm.RPL_NAMREPLY, b.storeNames)
+		b.i.AddCallback(ircm.RPL_ENDOFNAMES, b.endNames)
+		b.i.SendRaw("NAMES " + msg.Channel)
+	}
+	return ""
+}
+
+func (b *Birc) Connect() error {
+	flog.Infof("Connecting %s", b.Config.Server)
+	i := irc.IRC(b.Config.Nick, b.Config.Nick)
+	if log.GetLevel() == log.DebugLevel {
+		i.Debug = true
+	}
+	i.UseTLS = b.Config.UseTLS
+	i.UseSASL = b.Config.UseSASL
+	i.SASLLogin = b.Config.NickServNick
+	i.SASLPassword = b.Config.NickServPassword
+	i.TLSConfig = &tls.Config{InsecureSkipVerify: b.Config.SkipTLSVerify}
+	if b.Config.Password != "" {
+		i.Password = b.Config.Password
+	}
+	i.AddCallback(ircm.RPL_WELCOME, b.handleNewConnection)
+	err := i.Connect(b.Config.Server)
+	if err != nil {
+		return err
+	}
+	b.i = i
+	select {
+	case <-b.connected:
+		flog.Info("Connection succeeded")
+	case <-time.After(time.Second * 30):
+		return fmt.Errorf("connection timed out")
+	}
+	i.Debug = false
+	go b.doSend()
+	return nil
+}
+
+func (b *Birc) JoinChannel(channel string) error {
+	b.i.Join(channel)
+	return nil
+}
+
+func (b *Birc) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	if msg.Account == b.Account {
+		return nil
+	}
+	if strings.HasPrefix(msg.Text, "!") {
+		b.Command(&msg)
+		return nil
+	}
+	for _, text := range strings.Split(msg.Text, "\n") {
+		if len(b.Local) < b.Config.MessageQueue {
+			if len(b.Local) == b.Config.MessageQueue-1 {
+				text = text + " <message clipped>"
+			}
+			b.Local <- config.Message{Text: text, Username: msg.Username, Channel: msg.Channel}
+		} else {
+			flog.Debugf("flooding, dropping message (queue at %d)", len(b.Local))
+		}
+	}
+	return nil
+}
+
+func (b *Birc) doSend() {
+	rate := time.Millisecond * time.Duration(b.Config.MessageDelay)
+	throttle := time.Tick(rate)
+	for msg := range b.Local {
+		<-throttle
+		b.i.Privmsg(msg.Channel, msg.Username+msg.Text)
+	}
+}
+
+func (b *Birc) endNames(event *irc.Event) {
+	channel := event.Arguments[1]
+	sort.Strings(b.names[channel])
+	maxNamesPerPost := (300 / b.nicksPerRow()) * b.nicksPerRow()
+	continued := false
+	for len(b.names[channel]) > maxNamesPerPost {
+		b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel][0:maxNamesPerPost], continued),
+			Channel: channel, Account: b.Account}
+		b.names[channel] = b.names[channel][maxNamesPerPost:]
+		continued = true
+	}
+	b.Remote <- config.Message{Username: b.Nick, Text: b.formatnicks(b.names[channel], continued),
+		Channel: channel, Account: b.Account}
+	b.names[channel] = nil
+	b.i.ClearCallback(ircm.RPL_NAMREPLY)
+	b.i.ClearCallback(ircm.RPL_ENDOFNAMES)
+}
+
+func (b *Birc) handleNewConnection(event *irc.Event) {
+	flog.Debug("Registering callbacks")
+	i := b.i
+	b.Nick = event.Arguments[0]
+	i.AddCallback("PRIVMSG", b.handlePrivMsg)
+	i.AddCallback("CTCP_ACTION", b.handlePrivMsg)
+	i.AddCallback(ircm.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
+	i.AddCallback(ircm.NOTICE, b.handleNotice)
+	//i.AddCallback(ircm.RPL_MYINFO, func(e *irc.Event) { flog.Infof("%s: %s", e.Code, strings.Join(e.Arguments[1:], " ")) })
+	i.AddCallback("PING", func(e *irc.Event) {
+		i.SendRaw("PONG :" + e.Message())
+		flog.Debugf("PING/PONG")
+	})
+	i.AddCallback("JOIN", b.handleJoinPart)
+	i.AddCallback("PART", b.handleJoinPart)
+	i.AddCallback("QUIT", b.handleJoinPart)
+	i.AddCallback("*", b.handleOther)
+	// we are now fully connected
+	b.connected <- struct{}{}
+}
+
+func (b *Birc) handleJoinPart(event *irc.Event) {
+	flog.Debugf("Sending JOIN_LEAVE event from %s to gateway", b.Account)
+	channel := event.Arguments[0]
+	if event.Code == "QUIT" {
+		channel = ""
+	}
+	b.Remote <- config.Message{Username: "system", Text: event.Nick + " " + strings.ToLower(event.Code) + "s", Channel: channel, Account: b.Account, Event: config.EVENT_JOIN_LEAVE}
+	flog.Debugf("handle %#v", event)
+}
+
+func (b *Birc) handleNotice(event *irc.Event) {
+	if strings.Contains(event.Message(), "This nickname is registered") && event.Nick == b.Config.NickServNick {
+		b.i.Privmsg(b.Config.NickServNick, "IDENTIFY "+b.Config.NickServPassword)
+	} else {
+		b.handlePrivMsg(event)
+	}
+}
+
+func (b *Birc) handleOther(event *irc.Event) {
+	switch event.Code {
+	case "372", "375", "376", "250", "251", "252", "253", "254", "255", "265", "266", "002", "003", "004", "005":
+		return
+	}
+	flog.Debugf("%#v", event.Raw)
+}
+
+func (b *Birc) handlePrivMsg(event *irc.Event) {
+	// don't forward queries to the bot
+	if event.Arguments[0] == b.Nick {
+		return
+	}
+	// don't forward message from ourself
+	if event.Nick == b.Nick {
+		return
+	}
+	flog.Debugf("handlePrivMsg() %s %s %#v", event.Nick, event.Message(), event)
+	msg := ""
+	if event.Code == "CTCP_ACTION" {
+		msg = event.Nick + " "
+	}
+	msg += event.Message()
+	// strip IRC colors
+	re := regexp.MustCompile(`[[:cntrl:]](\d+,|)\d+`)
+	msg = re.ReplaceAllString(msg, "")
+	flog.Debugf("Sending message from %s on %s to gateway", event.Arguments[0], b.Account)
+	b.Remote <- config.Message{Username: event.Nick, Text: msg, Channel: event.Arguments[0], Account: b.Account}
+}
+
+func (b *Birc) handleTopicWhoTime(event *irc.Event) {
+	parts := strings.Split(event.Arguments[2], "!")
+	t, err := strconv.ParseInt(event.Arguments[3], 10, 64)
+	if err != nil {
+		flog.Errorf("Invalid time stamp: %s", event.Arguments[3])
+	}
+	user := parts[0]
+	if len(parts) > 1 {
+		user += " [" + parts[1] + "]"
+	}
+	flog.Debugf("%s: Topic set by %s [%s]", event.Code, user, time.Unix(t, 0))
+}
+
+func (b *Birc) nicksPerRow() int {
+	return 4
+	/*
+		if b.Config.Mattermost.NicksPerRow < 1 {
+			return 4
+		}
+		return b.Config.Mattermost.NicksPerRow
+	*/
+}
+
+func (b *Birc) storeNames(event *irc.Event) {
+	channel := event.Arguments[2]
+	b.names[channel] = append(
+		b.names[channel],
+		strings.Split(strings.TrimSpace(event.Message()), " ")...)
+}
+
+func (b *Birc) formatnicks(nicks []string, continued bool) string {
+	return plainformatter(nicks, b.nicksPerRow())
+	/*
+		switch b.Config.Mattermost.NickFormatter {
+		case "table":
+			return tableformatter(nicks, b.nicksPerRow(), continued)
+		default:
+			return plainformatter(nicks, b.nicksPerRow())
+		}
+	*/
+}

bridge/mattermost/mattermost.go

@@ -0,0 +1,163 @@
+package bmattermost
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/matterclient"
+	"github.com/42wim/matterbridge/matterhook"
+	log "github.com/Sirupsen/logrus"
+)
+
+type MMhook struct {
+	mh *matterhook.Client
+}
+
+type MMapi struct {
+	mc            *matterclient.MMClient
+	mmMap         map[string]string
+	mmIgnoreNicks []string
+}
+
+type MMMessage struct {
+	Text     string
+	Channel  string
+	Username string
+}
+
+type Bmattermost struct {
+	MMhook
+	MMapi
+	Config  *config.Protocol
+	Remote  chan config.Message
+	name    string
+	TeamId  string
+	Account string
+}
+
+var flog *log.Entry
+var protocol = "mattermost"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *Bmattermost {
+	b := &Bmattermost{}
+	b.Config = &cfg
+	b.Remote = c
+	b.Account = account
+	b.mmMap = make(map[string]string)
+	return b
+}
+
+func (b *Bmattermost) Command(cmd string) string {
+	return ""
+}
+
+func (b *Bmattermost) Connect() error {
+	if !b.Config.UseAPI {
+		flog.Info("Connecting webhooks")
+		b.mh = matterhook.New(b.Config.URL,
+			matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
+				BindAddress: b.Config.BindAddress})
+	} else {
+		b.mc = matterclient.New(b.Config.Login, b.Config.Password,
+			b.Config.Team, b.Config.Server)
+		b.mc.SkipTLSVerify = b.Config.SkipTLSVerify
+		b.mc.NoTLS = b.Config.NoTLS
+		flog.Infof("Connecting %s (team: %s) on %s", b.Config.Login, b.Config.Team, b.Config.Server)
+		err := b.mc.Login()
+		if err != nil {
+			return err
+		}
+		flog.Info("Connection succeeded")
+		b.TeamId = b.mc.GetTeamId()
+		go b.mc.WsReceiver()
+	}
+	go b.handleMatter()
+	return nil
+}
+
+func (b *Bmattermost) JoinChannel(channel string) error {
+	// we can only join channels using the API
+	if b.Config.UseAPI {
+		return b.mc.JoinChannel(b.mc.GetChannelId(channel, ""))
+	}
+	return nil
+}
+
+func (b *Bmattermost) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	nick := msg.Username
+	message := msg.Text
+	channel := msg.Channel
+
+	if b.Config.PrefixMessagesWithNick {
+		/*if IsMarkup(message) {
+			message = nick + "\n\n" + message
+		} else {
+		*/
+		message = nick + " " + message
+		//}
+	}
+	if !b.Config.UseAPI {
+		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
+		matterMessage.Channel = channel
+		matterMessage.UserName = nick
+		matterMessage.Type = ""
+		matterMessage.Text = message
+		err := b.mh.Send(matterMessage)
+		if err != nil {
+			flog.Info(err)
+			return err
+		}
+		return nil
+	}
+	b.mc.PostMessage(b.mc.GetChannelId(channel, ""), message)
+	return nil
+}
+
+func (b *Bmattermost) handleMatter() {
+	flog.Debugf("Choosing API based Mattermost connection: %t", b.Config.UseAPI)
+	mchan := make(chan *MMMessage)
+	if b.Config.UseAPI {
+		go b.handleMatterClient(mchan)
+	} else {
+		go b.handleMatterHook(mchan)
+	}
+	for message := range mchan {
+		flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.Account)
+		b.Remote <- config.Message{Text: message.Text, Username: message.Username, Channel: message.Channel, Account: b.Account}
+	}
+}
+
+func (b *Bmattermost) handleMatterClient(mchan chan *MMMessage) {
+	for message := range b.mc.MessageChan {
+		// do not post our own messages back to irc
+		// only listen to message from our team
+		if message.Raw.Event == "posted" && b.mc.User.Username != message.Username && message.Raw.Data["team_id"].(string) == b.TeamId {
+			flog.Debugf("Receiving from matterclient %#v", message)
+			m := &MMMessage{}
+			m.Username = message.Username
+			m.Channel = message.Channel
+			m.Text = message.Text
+			if len(message.Post.FileIds) > 0 {
+				for _, link := range b.mc.GetPublicLinks(message.Post.FileIds) {
+					m.Text = m.Text + "\n" + link
+				}
+			}
+			mchan <- m
+		}
+	}
+}
+
+func (b *Bmattermost) handleMatterHook(mchan chan *MMMessage) {
+	for {
+		message := b.mh.Receive()
+		flog.Debugf("Receiving from matterhook %#v", message)
+		m := &MMMessage{}
+		m.Username = message.UserName
+		m.Text = message.Text
+		m.Channel = message.ChannelName
+		mchan <- m
+	}
+}

bridge/rocketchat/rocketchat.go

@@ -0,0 +1,82 @@
+package brocketchat
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/hook/rockethook"
+	"github.com/42wim/matterbridge/matterhook"
+	log "github.com/Sirupsen/logrus"
+)
+
+type MMhook struct {
+	mh *matterhook.Client
+	rh *rockethook.Client
+}
+
+type Brocketchat struct {
+	MMhook
+	Config  *config.Protocol
+	Remote  chan config.Message
+	name    string
+	Account string
+}
+
+var flog *log.Entry
+var protocol = "rocketchat"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *Brocketchat {
+	b := &Brocketchat{}
+	b.Config = &cfg
+	b.Remote = c
+	b.Account = account
+	return b
+}
+
+func (b *Brocketchat) Command(cmd string) string {
+	return ""
+}
+
+func (b *Brocketchat) Connect() error {
+	flog.Info("Connecting webhooks")
+	b.mh = matterhook.New(b.Config.URL,
+		matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
+			DisableServer: true})
+	b.rh = rockethook.New(b.Config.URL, rockethook.Config{BindAddress: b.Config.BindAddress})
+	go b.handleRocketHook()
+	return nil
+}
+
+func (b *Brocketchat) JoinChannel(channel string) error {
+	return nil
+}
+
+func (b *Brocketchat) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
+	matterMessage.Channel = msg.Channel
+	matterMessage.UserName = msg.Username
+	matterMessage.Type = ""
+	matterMessage.Text = msg.Text
+	err := b.mh.Send(matterMessage)
+	if err != nil {
+		flog.Info(err)
+		return err
+	}
+	return nil
+}
+
+func (b *Brocketchat) handleRocketHook() {
+	for {
+		message := b.rh.Receive()
+		flog.Debugf("Receiving from rockethook %#v", message)
+		// do not loop
+		if message.UserName == b.Config.Nick {
+			continue
+		}
+		flog.Debugf("Sending message from %s on %s to gateway", message.UserName, b.Account)
+		b.Remote <- config.Message{Text: message.Text, Username: message.UserName, Channel: message.ChannelName, Account: b.Account}
+	}
+}

bridge/slack/slack.go

@@ -0,0 +1,251 @@
+package bslack
+
+import (
+	"fmt"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/matterhook"
+	log "github.com/Sirupsen/logrus"
+	"github.com/nlopes/slack"
+	"regexp"
+	"strings"
+	"time"
+)
+
+type MMMessage struct {
+	Text     string
+	Channel  string
+	Username string
+	Raw      *slack.MessageEvent
+}
+
+type Bslack struct {
+	mh       *matterhook.Client
+	sc       *slack.Client
+	Config   *config.Protocol
+	rtm      *slack.RTM
+	Plus     bool
+	Remote   chan config.Message
+	Users    []slack.User
+	Account  string
+	si       *slack.Info
+	channels []slack.Channel
+}
+
+var flog *log.Entry
+var protocol = "slack"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *Bslack {
+	b := &Bslack{}
+	b.Config = &cfg
+	b.Remote = c
+	b.Account = account
+	return b
+}
+
+func (b *Bslack) Command(cmd string) string {
+	return ""
+}
+
+func (b *Bslack) Connect() error {
+	flog.Info("Connecting")
+	if !b.Config.UseAPI {
+		b.mh = matterhook.New(b.Config.URL,
+			matterhook.Config{BindAddress: b.Config.BindAddress})
+	} else {
+		b.sc = slack.New(b.Config.Token)
+		b.rtm = b.sc.NewRTM()
+		go b.rtm.ManageConnection()
+	}
+	flog.Info("Connection succeeded")
+	go b.handleSlack()
+	return nil
+}
+
+func (b *Bslack) JoinChannel(channel string) error {
+	// we can only join channels using the API
+	if b.Config.UseAPI {
+		_, err := b.sc.JoinChannel(channel)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (b *Bslack) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	if msg.Account == b.Account {
+		return nil
+	}
+	nick := msg.Username
+	message := msg.Text
+	channel := msg.Channel
+	if b.Config.PrefixMessagesWithNick {
+		message = nick + " " + message
+	}
+	if !b.Config.UseAPI {
+		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
+		matterMessage.Channel = channel
+		matterMessage.UserName = nick
+		matterMessage.Type = ""
+		matterMessage.Text = message
+		err := b.mh.Send(matterMessage)
+		if err != nil {
+			flog.Info(err)
+			return err
+		}
+		return nil
+	}
+	schannel, err := b.getChannelByName(channel)
+	if err != nil {
+		return err
+	}
+	np := slack.NewPostMessageParameters()
+	if b.Config.PrefixMessagesWithNick == true {
+		np.AsUser = true
+	}
+	np.Username = nick
+	np.IconURL = config.GetIconURL(&msg, b.Config)
+	if msg.Avatar != "" {
+		np.IconURL = msg.Avatar
+	}
+	b.sc.PostMessage(schannel.ID, message, np)
+
+	/*
+	   newmsg := b.rtm.NewOutgoingMessage(message, schannel.ID)
+	   b.rtm.SendMessage(newmsg)
+	*/
+
+	return nil
+}
+
+func (b *Bslack) getAvatar(user string) string {
+	var avatar string
+	if b.Users != nil {
+		for _, u := range b.Users {
+			if user == u.Name {
+				return u.Profile.Image48
+			}
+		}
+	}
+	return avatar
+}
+
+func (b *Bslack) getChannelByName(name string) (*slack.Channel, error) {
+	if b.channels == nil {
+		return nil, fmt.Errorf("%s: channel %s not found (no channels found)", b.Account, name)
+	}
+	for _, channel := range b.channels {
+		if channel.Name == name {
+			return &channel, nil
+		}
+	}
+	return nil, fmt.Errorf("%s: channel %s not found", b.Account, name)
+}
+
+func (b *Bslack) handleSlack() {
+	flog.Debugf("Choosing API based slack connection: %t", b.Config.UseAPI)
+	mchan := make(chan *MMMessage)
+	if b.Config.UseAPI {
+		go b.handleSlackClient(mchan)
+	} else {
+		go b.handleMatterHook(mchan)
+	}
+	time.Sleep(time.Second)
+	flog.Debug("Start listening for Slack messages")
+	for message := range mchan {
+		// do not send messages from ourself
+		if b.Config.UseAPI && message.Username == b.si.User.Name {
+			continue
+		}
+		texts := strings.Split(message.Text, "\n")
+		for _, text := range texts {
+			flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.Account)
+			b.Remote <- config.Message{Text: text, Username: message.Username, Channel: message.Channel, Account: b.Account, Avatar: b.getAvatar(message.Username)}
+		}
+	}
+}
+
+func (b *Bslack) handleSlackClient(mchan chan *MMMessage) {
+	count := 0
+	for msg := range b.rtm.IncomingEvents {
+		switch ev := msg.Data.(type) {
+		case *slack.MessageEvent:
+			// ignore first message
+			if count > 0 {
+				flog.Debugf("Receiving from slackclient %#v", ev)
+				//ev.ReplyTo
+				channel, err := b.rtm.GetChannelInfo(ev.Channel)
+				if err != nil {
+					continue
+				}
+				user, err := b.rtm.GetUserInfo(ev.User)
+				if err != nil {
+					continue
+				}
+				m := &MMMessage{}
+				m.Username = user.Name
+				m.Channel = channel.Name
+				m.Text = ev.Text
+				m.Raw = ev
+				m.Text = b.replaceMention(m.Text)
+				mchan <- m
+			}
+			count++
+		case *slack.OutgoingErrorEvent:
+			flog.Debugf("%#v", ev.Error())
+		case *slack.ChannelJoinedEvent:
+			b.Users, _ = b.sc.GetUsers()
+		case *slack.ConnectedEvent:
+			b.channels = ev.Info.Channels
+			b.si = ev.Info
+			b.Users, _ = b.sc.GetUsers()
+			// add private channels
+			groups, _ := b.sc.GetGroups(true)
+			for _, g := range groups {
+				channel := new(slack.Channel)
+				channel.ID = g.ID
+				channel.Name = g.Name
+				b.channels = append(b.channels, *channel)
+			}
+		case *slack.InvalidAuthEvent:
+			flog.Fatalf("Invalid Token %#v", ev)
+		default:
+		}
+	}
+}
+
+func (b *Bslack) handleMatterHook(mchan chan *MMMessage) {
+	for {
+		message := b.mh.Receive()
+		flog.Debugf("receiving from matterhook (slack) %#v", message)
+		m := &MMMessage{}
+		m.Username = message.UserName
+		m.Text = message.Text
+		m.Text = b.replaceMention(m.Text)
+		m.Channel = message.ChannelName
+		mchan <- m
+	}
+}
+
+func (b *Bslack) userName(id string) string {
+	for _, u := range b.Users {
+		if u.ID == id {
+			return u.Name
+		}
+	}
+	return ""
+}
+
+func (b *Bslack) replaceMention(text string) string {
+	results := regexp.MustCompile(`<@([a-zA-z0-9]+)>`).FindAllStringSubmatch(text, -1)
+	for _, r := range results {
+		text = strings.Replace(text, "<@"+r[1]+">", "@"+b.userName(r[1]), -1)
+
+	}
+	return text
+}

bridge/telegram/telegram.go

@@ -0,0 +1,161 @@
+package btelegram
+
+import (
+	"bytes"
+	"html"
+	"strconv"
+
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/Sirupsen/logrus"
+	"github.com/go-telegram-bot-api/telegram-bot-api"
+	"github.com/russross/blackfriday"
+)
+
+type Btelegram struct {
+	c       *tgbotapi.BotAPI
+	Config  *config.Protocol
+	Remote  chan config.Message
+	Account string
+}
+
+var flog *log.Entry
+var protocol = "telegram"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *Btelegram {
+	b := &Btelegram{}
+	b.Config = &cfg
+	b.Remote = c
+	b.Account = account
+	return b
+}
+
+func (b *Btelegram) Connect() error {
+	var err error
+	flog.Info("Connecting")
+	b.c, err = tgbotapi.NewBotAPI(b.Config.Token)
+	if err != nil {
+		flog.Debugf("%#v", err)
+		return err
+	}
+	updates, err := b.c.GetUpdatesChan(tgbotapi.NewUpdate(0))
+	if err != nil {
+		flog.Debugf("%#v", err)
+		return err
+	}
+	flog.Info("Connection succeeded")
+	go b.handleRecv(updates)
+	return nil
+}
+
+func (b *Btelegram) JoinChannel(channel string) error {
+	return nil
+}
+
+type customHtml struct {
+	blackfriday.Renderer
+}
+
+func (options *customHtml) Paragraph(out *bytes.Buffer, text func() bool) {
+	marker := out.Len()
+
+	if !text() {
+		out.Truncate(marker)
+		return
+	}
+	out.WriteString("\n")
+}
+
+func (options *customHtml) BlockCode(out *bytes.Buffer, text []byte, lang string) {
+	out.WriteString("<pre>")
+
+	out.WriteString(html.EscapeString(string(text)))
+	out.WriteString("</pre>\n")
+}
+
+func (options *customHtml) Header(out *bytes.Buffer, text func() bool, level int, id string) {
+	options.Paragraph(out, text)
+}
+
+func (options *customHtml) HRule(out *bytes.Buffer) {
+	out.WriteByte('\n')
+}
+
+func (options *customHtml) BlockQuote(out *bytes.Buffer, text []byte) {
+	out.WriteString("> ")
+	out.Write(text)
+	out.WriteByte('\n')
+}
+
+func (options *customHtml) List(out *bytes.Buffer, text func() bool, flags int) {
+	options.Paragraph(out, text)
+}
+
+func (options *customHtml) ListItem(out *bytes.Buffer, text []byte, flags int) {
+	out.WriteString("- ")
+	out.Write(text)
+	out.WriteByte('\n')
+}
+
+func (b *Btelegram) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	chatid, err := strconv.ParseInt(msg.Channel, 10, 64)
+	if err != nil {
+		return err
+	}
+
+	parsed := blackfriday.Markdown([]byte(msg.Text),
+		&customHtml{blackfriday.HtmlRenderer(blackfriday.HTML_USE_XHTML|blackfriday.HTML_SKIP_IMAGES, "", "")},
+		blackfriday.EXTENSION_NO_INTRA_EMPHASIS|
+			blackfriday.EXTENSION_FENCED_CODE|
+			blackfriday.EXTENSION_AUTOLINK|
+			blackfriday.EXTENSION_SPACE_HEADERS|
+			blackfriday.EXTENSION_HEADER_IDS|
+			blackfriday.EXTENSION_BACKSLASH_LINE_BREAK|
+			blackfriday.EXTENSION_DEFINITION_LISTS)
+
+	m := tgbotapi.NewMessage(chatid, html.EscapeString(msg.Username)+string(parsed))
+	m.ParseMode = "HTML"
+	_, err = b.c.Send(m)
+	return err
+}
+
+func (b *Btelegram) handleRecv(updates <-chan tgbotapi.Update) {
+	username := ""
+	text := ""
+	channel := ""
+	for update := range updates {
+		// handle channels
+		if update.ChannelPost != nil {
+			if update.ChannelPost.From != nil {
+				username = update.ChannelPost.From.FirstName
+				if username == "" {
+					username = update.ChannelPost.From.UserName
+				}
+			}
+			text = update.ChannelPost.Text
+			channel = strconv.FormatInt(update.ChannelPost.Chat.ID, 10)
+		}
+		// handle groups
+		if update.Message != nil {
+			if update.Message.From != nil {
+				username = update.Message.From.FirstName
+				if username == "" {
+					username = update.Message.From.UserName
+				}
+			}
+			text = update.Message.Text
+			channel = strconv.FormatInt(update.Message.Chat.ID, 10)
+		}
+		if username == "" {
+			username = "unknown"
+		}
+		if text != "" {
+			flog.Debugf("Sending message from %s on %s to gateway", username, b.Account)
+			b.Remote <- config.Message{Username: username, Text: text, Channel: channel, Account: b.Account}
+		}
+	}
+}

bridge/xmpp/xmpp.go

@@ -0,0 +1,134 @@
+package bxmpp
+
+import (
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/Sirupsen/logrus"
+	"github.com/mattn/go-xmpp"
+	"crypto/tls"
+
+	"strings"
+	"time"
+)
+
+type Bxmpp struct {
+	xc      *xmpp.Client
+	xmppMap map[string]string
+	Config  *config.Protocol
+	Remote  chan config.Message
+	Account string
+}
+
+var flog *log.Entry
+var protocol = "xmpp"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *Bxmpp {
+	b := &Bxmpp{}
+	b.xmppMap = make(map[string]string)
+	b.Config = &cfg
+	b.Account = account
+	b.Remote = c
+	return b
+}
+
+func (b *Bxmpp) Connect() error {
+	var err error
+	flog.Infof("Connecting %s", b.Config.Server)
+	b.xc, err = b.createXMPP()
+	if err != nil {
+		flog.Debugf("%#v", err)
+		return err
+	}
+	flog.Info("Connection succeeded")
+	go b.handleXmpp()
+	return nil
+}
+
+func (b *Bxmpp) JoinChannel(channel string) error {
+	b.xc.JoinMUCNoHistory(channel+"@"+b.Config.Muc, b.Config.Nick)
+	return nil
+}
+
+func (b *Bxmpp) Send(msg config.Message) error {
+	flog.Debugf("Receiving %#v", msg)
+	b.xc.Send(xmpp.Chat{Type: "groupchat", Remote: msg.Channel + "@" + b.Config.Muc, Text: msg.Username + msg.Text})
+	return nil
+}
+
+func (b *Bxmpp) createXMPP() (*xmpp.Client, error) {
+	tc := new(tls.Config)
+	tc.InsecureSkipVerify = b.Config.SkipTLSVerify
+	tc.ServerName = strings.Split(b.Config.Server, ":")[0]
+	options := xmpp.Options{
+		Host:     b.Config.Server,
+		User:     b.Config.Jid,
+		Password: b.Config.Password,
+		NoTLS:    true,
+		StartTLS: true,
+		TLSConfig: tc,
+
+		//StartTLS:      false,
+		Debug:                        true,
+		Session:                      true,
+		Status:                       "",
+		StatusMessage:                "",
+		Resource:                     "",
+		InsecureAllowUnencryptedAuth: false,
+		//InsecureAllowUnencryptedAuth: true,
+	}
+	var err error
+	b.xc, err = options.NewClient()
+	return b.xc, err
+}
+
+func (b *Bxmpp) xmppKeepAlive() chan bool {
+	done := make(chan bool)
+	go func() {
+		ticker := time.NewTicker(90 * time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				b.xc.PingC2S("", "")
+			case <-done:
+				return
+			}
+		}
+	}()
+	return done
+}
+
+func (b *Bxmpp) handleXmpp() error {
+	done := b.xmppKeepAlive()
+	defer close(done)
+	nodelay := time.Time{}
+	for {
+		m, err := b.xc.Recv()
+		if err != nil {
+			return err
+		}
+		switch v := m.(type) {
+		case xmpp.Chat:
+			var channel, nick string
+			if v.Type == "groupchat" {
+				s := strings.Split(v.Remote, "@")
+				if len(s) == 2 {
+					channel = s[0]
+				}
+				s = strings.Split(s[1], "/")
+				if len(s) == 2 {
+					nick = s[1]
+				}
+				if nick != b.Config.Nick && v.Stamp == nodelay && v.Text != "" {
+					flog.Debugf("Sending message from %s on %s to gateway", nick, b.Account)
+					b.Remote <- config.Message{Username: nick, Text: v.Text, Channel: channel, Account: b.Account}
+				}
+			}
+		case xmpp.Presence:
+			// do nothing
+		}
+	}
+}

changelog.md

@@ -0,0 +1,175 @@
+# v0.9.2
+## Bugfix
+* general: make ignorenicks work again #115
+* telegram: fix receiving from channels and groups #112
+* telegram: use html for username
+* telegram: use ```unknown``` as username when username is not visible.
+* irc: update vendor (fixes some crashes) #117
+* xmpp: fix tls by setting ServerName #114
+
+## New features
+* slack: support private channels #118
+
+# v0.9.1
+## New features
+* Rocket.Chat: New protocol support added (https://rocket.chat)
+* irc: add channel key support #27 (see matterbrige.toml.sample for example)
+* xmpp: add SkipTLSVerify #106
+
+## Bugfix
+* general: Exit when a bridge fails to start
+* mattermost: Check errors only on first connect. Keep retrying after first connection succeeds. #95
+* telegram: fix missing username #102
+* slack: do not use API functions in webhook (slack) #110
+
+# v0.9.0
+## New features
+* Telegram: New protocol support added (https://telegram.org)
+* Hipchat: Add sample config to connect to hipchat via xmpp
+* discord: add "Bot " tag to discord tokens automatically
+* slack: Add support for dynamic Iconurl #43
+* general: Add ```gateway.inout``` config option for bidirectional bridges #85
+* general: Add ```[general]``` section so that ```RemoteNickFormat``` can be set globally
+
+## Bugfix
+* general: when using samechannelgateway NickFormat get doubled by the NICK #77
+* general: fix ShowJoinPart for messages from irc bridge #72
+* gitter: fix high cpu usage #89
+* irc: fix !users command #78
+* xmpp: fix keepalive
+* xmpp: do not relay delayed/empty messages
+* slack: Replace id-mentions to usernames #86 
+* mattermost: fix public links not working (API changes)
+
+# v0.8.1
+## Bugfix
+* general: when using samechannelgateway NickFormat get doubled by the NICK #77
+* irc: fix !users command #78
+
+# v0.8.0
+Release because of breaking mattermost API changes
+## New features
+* Supports mattermost v3.5.0
+
+# v0.7.1
+## Bugfix
+* general: when using samechannelgateway NickFormat get doubled by the NICK #77
+* irc: fix !users command #78
+
+# v0.7.0
+## Breaking config changes from 0.6 to 0.7
+Matterbridge now uses TOML configuration (https://github.com/toml-lang/toml)
+See matterbridge.toml.sample for an example
+
+## New features
+### General
+* Allow for bridging the same type of bridge, which means you can eg bridge between multiple mattermosts.
+* The bridge is now actually a gateway which has support multiple in and out bridges. (and supports multiple gateways).
+* Discord support added. See matterbridge.toml.sample for more information.
+* Samechannelgateway support added, easier configuration for 1:1 mapping of protocols with same channel names. #35
+* Support for override from environment variables. #50
+* Better debugging output.
+* discord: New protocol support added. (http://www.discordapp.com)
+* mattermost: Support attachments.
+* irc: Strip colors. #33
+* irc: Anti-flooding support. #40
+* irc: Forward channel notices.
+
+## Bugfix
+* irc: Split newlines. #37
+* irc: Only respond to nick related notices from nickserv.
+* irc: Ignore queries send to the bot.
+* irc: Ignore messages from ourself.
+* irc: Only output the "users on irc information" when asked with "!users".
+* irc: Actually wait until connection is complete before saying it is.
+* mattermost: Fix mattermost channel joins.
+* mattermost: Drop messages not from our team.
+* slack: Do not panic on non-existing channels.
+* general: Exit when a bridge fails to start.
+
+# v0.6.1
+## New features
+* Slack support added.  See matterbridge.conf.sample for more information
+
+## Bugfix
+* Fix 100% CPU bug on incorrect closed connections
+
+# v0.6.0-beta2
+## New features
+* Gitter support added.  See matterbridge.conf.sample for more information
+
+# v0.6.0-beta1
+## Breaking changes from 0.5 to 0.6
+### commandline
+* -plus switch deprecated. Use ```Plus=true``` or ```Plus``` in ```[general]``` section
+
+### IRC section
+* ```Enabled``` added (default false)  
+Add ```Enabled=true``` or ```Enabled``` to the ```[IRC]``` section if you want to enable the IRC bridge
+
+### Mattermost section
+* ```Enabled``` added (default false)  
+Add ```Enabled=true``` or ```Enabled``` to the ```[mattermost]``` section if you want to enable the mattermost bridge
+
+### General section
+* Use ```Plus=true``` or ```Plus``` in ```[general]``` section to enable the API version of matterbridge
+
+## New features
+* Matterbridge now bridges between any specified protocol (not only mattermost anymore) 
+* XMPP support added.  See matterbridge.conf.sample for more information
+* RemoteNickFormat {BRIDGE} variable added  
+You can now add the originating bridge to ```RemoteNickFormat```  
+eg ```RemoteNickFormat="[{BRIDGE}] <{NICK}> "```
+
+
+# v0.5.0
+## Breaking changes from 0.4 to 0.5 for matterbridge (webhooks version)
+### IRC section
+#### Server
+Port removed, added to server
+```
+server="irc.freenode.net"
+port=6667
+```
+changed to
+```
+server="irc.freenode.net:6667"
+```
+#### Channel
+Removed see Channels section below
+
+#### UseSlackCircumfix=true
+Removed, can be done by using ```RemoteNickFormat="<{NICK}> "```
+
+### Mattermost section
+#### BindAddress
+Port removed, added to BindAddress
+
+```
+BindAddress="0.0.0.0"
+port=9999
+```
+
+changed to
+
+```
+BindAddress="0.0.0.0:9999"
+```
+
+#### Token
+Removed
+
+### Channels section
+```
+[Token "outgoingwebhooktoken1"] 
+IRCChannel="#off-topic"
+MMChannel="off-topic"
+```
+
+changed to
+
+```
+[Channel "channelnameofchoice"] 
+IRC="#off-topic"
+Mattermost="off-topic"
+```

gateway/gateway.go

@@ -0,0 +1,187 @@
+package gateway
+
+import (
+	"fmt"
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/Sirupsen/logrus"
+	"reflect"
+	"strings"
+)
+
+type Gateway struct {
+	*config.Config
+	MyConfig *config.Gateway
+	//Bridges     []*bridge.Bridge
+	Bridges        map[string]*bridge.Bridge
+	ChannelsOut    map[string][]string
+	ChannelsIn     map[string][]string
+	ChannelOptions map[string]config.ChannelOptions
+	Name           string
+	Message        chan config.Message
+}
+
+func New(cfg *config.Config, gateway *config.Gateway) *Gateway {
+	gw := &Gateway{}
+	gw.Name = gateway.Name
+	gw.Config = cfg
+	gw.MyConfig = gateway
+	gw.Message = make(chan config.Message)
+	gw.Bridges = make(map[string]*bridge.Bridge)
+	return gw
+}
+
+func (gw *Gateway) AddBridge(cfg *config.Bridge) error {
+	for _, br := range gw.Bridges {
+		if br.Account == cfg.Account {
+			return nil
+		}
+	}
+	log.Infof("Starting bridge: %s ", cfg.Account)
+	br := bridge.New(gw.Config, cfg, gw.Message)
+	gw.Bridges[cfg.Account] = br
+	err := br.Connect()
+	if err != nil {
+		return fmt.Errorf("Bridge %s failed to start: %v", br.Account, err)
+	}
+	exists := make(map[string]bool)
+	for _, channel := range append(gw.ChannelsOut[br.Account], gw.ChannelsIn[br.Account]...) {
+		if !exists[br.Account+channel] {
+			mychannel := channel
+			log.Infof("%s: joining %s", br.Account, channel)
+			if br.Protocol == "irc" && gw.ChannelOptions[br.Account+channel].Key != "" {
+				log.Debugf("using key %s for channel %s", gw.ChannelOptions[br.Account+channel].Key, channel)
+				mychannel = mychannel + " " + gw.ChannelOptions[br.Account+channel].Key
+			}
+			br.JoinChannel(mychannel)
+			exists[br.Account+channel] = true
+		}
+	}
+	return nil
+}
+
+func (gw *Gateway) Start() error {
+	gw.mapChannels()
+	for _, br := range append(gw.MyConfig.In, append(gw.MyConfig.InOut, gw.MyConfig.Out...)...) {
+		err := gw.AddBridge(&br)
+		if err != nil {
+			return err
+		}
+	}
+	go gw.handleReceive()
+	return nil
+}
+
+func (gw *Gateway) handleReceive() {
+	for {
+		select {
+		case msg := <-gw.Message:
+			if !gw.ignoreMessage(&msg) {
+				for _, br := range gw.Bridges {
+					gw.handleMessage(msg, br)
+				}
+			}
+		}
+	}
+}
+
+func (gw *Gateway) mapChannels() error {
+	options := make(map[string]config.ChannelOptions)
+	m := make(map[string][]string)
+	for _, br := range gw.MyConfig.Out {
+		m[br.Account] = append(m[br.Account], br.Channel)
+		options[br.Account+br.Channel] = br.Options
+	}
+	gw.ChannelsOut = m
+	m = nil
+	m = make(map[string][]string)
+	for _, br := range gw.MyConfig.In {
+		m[br.Account] = append(m[br.Account], br.Channel)
+		options[br.Account+br.Channel] = br.Options
+	}
+	gw.ChannelsIn = m
+	for _, br := range gw.MyConfig.InOut {
+		gw.ChannelsIn[br.Account] = append(gw.ChannelsIn[br.Account], br.Channel)
+		gw.ChannelsOut[br.Account] = append(gw.ChannelsOut[br.Account], br.Channel)
+		options[br.Account+br.Channel] = br.Options
+	}
+	gw.ChannelOptions = options
+	return nil
+}
+
+func (gw *Gateway) getDestChannel(msg *config.Message, dest string) []string {
+	channels := gw.ChannelsIn[msg.Account]
+	// broadcast to every out channel (irc QUIT)
+	if msg.Event == config.EVENT_JOIN_LEAVE && msg.Channel == "" {
+		return gw.ChannelsOut[dest]
+	}
+	for _, channel := range channels {
+		if channel == msg.Channel {
+			return gw.ChannelsOut[dest]
+		}
+	}
+	return []string{}
+}
+
+func (gw *Gateway) handleMessage(msg config.Message, dest *bridge.Bridge) {
+	// only relay join/part when configged
+	if msg.Event == config.EVENT_JOIN_LEAVE && !gw.Bridges[dest.Account].Config.ShowJoinPart {
+		return
+	}
+	originchannel := msg.Channel
+	channels := gw.getDestChannel(&msg, dest.Account)
+	for _, channel := range channels {
+		// do not send the message to the bridge we come from if also the channel is the same
+		if msg.Account == dest.Account && channel == originchannel {
+			continue
+		}
+		msg.Channel = channel
+		if msg.Channel == "" {
+			log.Debug("empty channel")
+			return
+		}
+		log.Debugf("Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, originchannel, dest.Account, channel)
+		gw.modifyUsername(&msg, dest)
+		err := dest.Send(msg)
+		if err != nil {
+			fmt.Println(err)
+		}
+	}
+}
+
+func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
+	for _, entry := range strings.Fields(gw.Bridges[msg.Account].Config.IgnoreNicks) {
+		if msg.Username == entry {
+			log.Debugf("ignoring %s from %s", msg.Username, msg.Account)
+			return true
+		}
+	}
+	return false
+}
+
+func (gw *Gateway) modifyMessage(msg *config.Message, dest *bridge.Bridge) {
+	val := reflect.ValueOf(gw.Config).Elem()
+	for i := 0; i < val.NumField(); i++ {
+		typeField := val.Type().Field(i)
+		// look for the protocol map (both lowercase)
+		if strings.ToLower(typeField.Name) == dest.Protocol {
+			// get the Protocol struct from the map
+			protoCfg := val.Field(i).MapIndex(reflect.ValueOf(dest.Name))
+			//config.SetNickFormat(msg, protoCfg.Interface().(config.Protocol))
+			val.Field(i).SetMapIndex(reflect.ValueOf(dest.Name), protoCfg)
+			break
+		}
+	}
+}
+
+func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) {
+	br := gw.Bridges[msg.Account]
+	nick := gw.Config.General.RemoteNickFormat
+	if nick == "" {
+		nick = dest.Config.RemoteNickFormat
+	}
+	nick = strings.Replace(nick, "{NICK}", msg.Username, -1)
+	nick = strings.Replace(nick, "{BRIDGE}", br.Name, -1)
+	nick = strings.Replace(nick, "{PROTOCOL}", br.Protocol, -1)
+	msg.Username = nick
+}

gateway/samechannel/samechannel.go

@@ -0,0 +1,105 @@
+package samechannelgateway
+
+import (
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	log "github.com/Sirupsen/logrus"
+	"strings"
+)
+
+type SameChannelGateway struct {
+	*config.Config
+	MyConfig    *config.SameChannelGateway
+	Bridges     map[string]*bridge.Bridge
+	Channels    []string
+	ignoreNicks map[string][]string
+	Name        string
+}
+
+func New(cfg *config.Config, gateway *config.SameChannelGateway) error {
+	c := make(chan config.Message)
+	gw := &SameChannelGateway{}
+	gw.Bridges = make(map[string]*bridge.Bridge)
+	gw.Name = gateway.Name
+	gw.Config = cfg
+	gw.MyConfig = gateway
+	gw.Channels = gateway.Channels
+	for _, account := range gateway.Accounts {
+		br := config.Bridge{Account: account}
+		log.Infof("Starting bridge: %s", account)
+		gw.Bridges[account] = bridge.New(cfg, &br, c)
+	}
+	for _, br := range gw.Bridges {
+		err := br.Connect()
+		if err != nil {
+			log.Fatalf("Bridge %s failed to start: %v", br.Account, err)
+		}
+		for _, channel := range gw.Channels {
+			log.Infof("%s: joining %s", br.Account, channel)
+			br.JoinChannel(channel)
+		}
+	}
+	gw.handleReceive(c)
+	return nil
+}
+
+func (gw *SameChannelGateway) handleReceive(c chan config.Message) {
+	for {
+		select {
+		case msg := <-c:
+			if !gw.ignoreMessage(&msg) {
+				for _, br := range gw.Bridges {
+					gw.handleMessage(msg, br)
+				}
+			}
+		}
+	}
+}
+
+func (gw *SameChannelGateway) handleMessage(msg config.Message, dest *bridge.Bridge) {
+	// is this a configured channel
+	if !gw.validChannel(msg.Channel) {
+		return
+	}
+	// do not send the message to the bridge we come from if also the channel is the same
+	if msg.Account == dest.Account {
+		return
+	}
+	gw.modifyUsername(&msg, dest)
+	log.Debugf("Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, msg.Channel, dest.Account, msg.Channel)
+	err := dest.Send(msg)
+	if err != nil {
+		log.Error(err)
+	}
+}
+
+func (gw *SameChannelGateway) ignoreMessage(msg *config.Message) bool {
+	for _, entry := range strings.Fields(gw.Bridges[msg.Account].Config.IgnoreNicks) {
+		if msg.Username == entry {
+			log.Debugf("ignoring %s from %s", msg.Username, msg.Account)
+			return true
+		}
+	}
+	return false
+}
+
+func (gw *SameChannelGateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) {
+	br := gw.Bridges[msg.Account]
+	nick := gw.Config.General.RemoteNickFormat
+	if nick == "" {
+		nick = dest.Config.RemoteNickFormat
+	}
+	nick = strings.Replace(nick, "{NICK}", msg.Username, -1)
+	nick = strings.Replace(nick, "{BRIDGE}", br.Name, -1)
+	nick = strings.Replace(nick, "{PROTOCOL}", br.Protocol, -1)
+	msg.Username = nick
+}
+
+func (gw *SameChannelGateway) validChannel(channel string) bool {
+	for _, c := range gw.Channels {
+		if c == channel {
+			return true
+		}
+	}
+	return false
+}

hook/rockethook/rockethook.go

@@ -0,0 +1,108 @@
+package rockethook
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+)
+
+// Message for rocketchat outgoing webhook.
+type Message struct {
+	Token       string `json:"token"`
+	ChannelID   string `json:"channel_id"`
+	ChannelName string `json:"channel_name"`
+	Timestamp   string `json:"timestamp"`
+	UserID      string `json:"user_id"`
+	UserName    string `json:"user_name"`
+	Text        string `json:"text"`
+}
+
+// Client for Rocketchat.
+type Client struct {
+	In         chan Message
+	httpclient *http.Client
+	Config
+}
+
+// Config for client.
+type Config struct {
+	BindAddress        string // Address to listen on
+	Token              string // Only allow this token from Rocketchat. (Allow everything when empty)
+	InsecureSkipVerify bool   // disable certificate checking
+}
+
+// New Rocketchat client.
+func New(url string, config Config) *Client {
+	c := &Client{In: make(chan Message), Config: config}
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: config.InsecureSkipVerify},
+	}
+	c.httpclient = &http.Client{Transport: tr}
+	_, _, err := net.SplitHostPort(c.BindAddress)
+	if err != nil {
+		log.Fatalf("incorrect bindaddress %s", c.BindAddress)
+	}
+	go c.StartServer()
+	return c
+}
+
+// StartServer starts a webserver listening for incoming mattermost POSTS.
+func (c *Client) StartServer() {
+	mux := http.NewServeMux()
+	mux.Handle("/", c)
+	log.Printf("Listening on http://%v...\n", c.BindAddress)
+	if err := http.ListenAndServe(c.BindAddress, mux); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// ServeHTTP implementation.
+func (c *Client) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		log.Println("invalid " + r.Method + " connection from " + r.RemoteAddr)
+		http.NotFound(w, r)
+		return
+	}
+	msg := Message{}
+	body, err := ioutil.ReadAll(r.Body)
+	log.Println(string(body))
+	if err != nil {
+		log.Println(err)
+		http.NotFound(w, r)
+		return
+	}
+	defer r.Body.Close()
+	err = json.Unmarshal(body, &msg)
+	if err != nil {
+		log.Println(err)
+		http.NotFound(w, r)
+		return
+	}
+	if msg.Token == "" {
+		log.Println("no token from " + r.RemoteAddr)
+		http.NotFound(w, r)
+		return
+	}
+	msg.ChannelName = "#" + msg.ChannelName
+	if c.Token != "" {
+		if msg.Token != c.Token {
+			log.Println("invalid token " + msg.Token + " from " + r.RemoteAddr)
+			http.NotFound(w, r)
+			return
+		}
+	}
+	c.In <- msg
+}
+
+// Receive returns an incoming message from mattermost outgoing webhooks URL.
+func (c *Client) Receive() Message {
+	for {
+		select {
+		case msg := <-c.In:
+			return msg
+		}
+	}
+}

matterbridge.conf.sample

@@ -1,148 +0,0 @@
-#This is configuration for matterbridge.
-###################################################################
-#IRC section
-###################################################################
-[IRC]
-#irc server to connect to. 
-#REQUIRED
-Server="irc.freenode.net:6667"
-
-#Enable to use TLS connection to your irc server. 
-#OPTIONAL (default false)
-UseTLS=false
-
-#Enable SASL (PLAIN) authentication. (freenode requires this from eg AWS hosts)
-#It uses NickServNick and NickServPassword as login and password
-#OPTIONAL (deefault false)
-UseSASL=false
-
-#Enable to not verify the certificate on your irc server. i
-#e.g. when using selfsigned certificates
-#OPTIONAL (default false)
-SkipTLSVerify=true
-
-#Your nick on irc. 
-#REQUIRED
-Nick="matterbot"
-
-#If you registered your bot with a service like Nickserv on freenode. 
-#Also being used when UseSASL=true
-#OPTIONAL
-NickServNick="nickserv"
-NickServPassword="secret"
-
-#RemoteNickFormat defines how Mattermost users appear on irc
-#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
-#OPTIONAL (default NICK:)
-RemoteNickFormat="{NICK}: "
-
-#Nicks you want to ignore. 
-#Messages from those users will not be sent to mattermost.
-#OPTIONAL
-IgnoreNicks="ircspammer1 ircspammer2"
-
-###################################################################
-#mattermost section
-###################################################################
-
-[mattermost]
-#### Settings for webhook matterbridge.
-#### These settings will not be used when using -plus switch which doesn't use 
-#### webhooks.
-
-#Url is your incoming webhook url as specified in mattermost. 
-#See account settings - integrations - incoming webhooks on mattermost.
-#REQUIRED
-URL="https://yourdomain/hooks/yourhookkey"
-
-#Address to listen on for outgoing webhook requests from mattermost.
-#See account settings - integrations - outgoing webhooks on mattermost.
-#This setting will not be used when using -plus switch which doesn't use 
-#webhooks
-#REQUIRED
-BindAddress="0.0.0.0:9999"
-
-#Icon that will be showed in mattermost. 
-#OPTIONAL
-IconURL="http://youricon.png"
-
-#### Settings for matterbridge -plus
-#### Thse settings will only be used when using the -plus switch.
-
-#The mattermost hostname. 
-#REQUIRED
-Server="yourmattermostserver.domain"
-
-#Your team on mattermost. 
-#REQUIRED
-Team="yourteam"
-
-#login/pass of your bot. 
-#Use a dedicated user for this and not your own! 
-#REQUIRED
-Login="yourlogin"
-Password="yourpass"
-
-#Disable to make a http connection to your mattermost. 
-#OPTIONAL (default false)
-NoTLS=false
-
-#### Shared settings for matterbridge and -plus
-
-#Enable to not verify the certificate on your mattermost server. 
-#e.g. when using selfsigned certificates
-#OPTIONAL (default false)
-SkipTLSVerify=true
-
-#Enable to show IRC joins/parts in mattermost. 
-#OPTIONAL (default false)
-ShowJoinPart=false
-
-#Whether to prefix messages from IRC to mattermost with the sender's nick. 
-#Useful if username overrides for incoming webhooks isn't enabled on the 
-#mattermost server. If you set PrefixMessagesWithNick to true, each message 
-#from IRC to Mattermost will by default be prefixed by "irc-" + nick. You can, 
-#however, modify how the messages appear, by setting (and modifying) RemoteNickFormat 
-#OPTIONAL (default false)
-PrefixMessagesWithNick=false
-
-#RemoteNickFormat defines how IRC users appear on Mattermost. 
-#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
-#OPTIONAL (default irc-NICK)
-RemoteNickFormat="irc-{NICK}"
-
-#how to format the list of IRC nicks when displayed in mattermost. 
-#Possible options are "table" and "plain"
-#OPTIONAL (default plain)
-NickFormatter=plain
-#How many nicks to list per row for formatters that support this. 
-#OPTIONAL (default 4)
-NicksPerRow=4
-
-#Nicks you want to ignore. Messages from those users will not be sent to IRC. 
-#OPTIONAL 
-IgnoreNicks="mmbot spammer2"
-
-###################################################################
-#multiple channel config
-###################################################################
-#You can specify multiple channels. 
-#The name is just an identifier for you.
-#REQUIRED (at least 1 channel)
-[Channel "channel1"] 
-#Choose the IRC channel to send mattermost messages to.
-IRC="#off-topic"
-#Choose the mattermost channel to send IRC messages to.
-mattermost="off-topic"
-
-[Channel "testchannel"]
-IRC="#testing"
-mattermost="testing"
-
-###################################################################
-#general
-###################################################################
-[general]
-#request your API key on https://github.com/giphy/GiphyAPI. This is a public beta key. 
-#OPTIONAL
-GiphyApiKey="dc6zaTOxFJmzC"

matterbridge.go

@@ -3,21 +3,22 @@ package main
 import (
 	"flag"
 	"fmt"
-	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/gateway"
+	"github.com/42wim/matterbridge/gateway/samechannel"
 	log "github.com/Sirupsen/logrus"
 )
 
-var version = "0.5.0-beta2"
+var version = "0.9.2"
 
 func init() {
 	log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
 }
 
 func main() {
-	flagConfig := flag.String("conf", "matterbridge.conf", "config file")
+	flagConfig := flag.String("conf", "matterbridge.toml", "config file")
 	flagDebug := flag.Bool("debug", false, "enable debug")
 	flagVersion := flag.Bool("version", false, "show version")
-	flagPlus := flag.Bool("plus", false, "running using API instead of webhooks")
 	flag.Parse()
 	if *flagVersion {
 		fmt.Println("version:", version)
@@ -29,10 +30,30 @@ func main() {
 		log.SetLevel(log.DebugLevel)
 	}
 	fmt.Println("running version", version)
-	if *flagPlus {
+	cfg := config.NewConfig(*flagConfig)
-		bridge.NewBridge("matterbot", bridge.NewConfig(*flagConfig), "")
+	for _, gw := range cfg.SameChannelGateway {
-	} else {
+		if !gw.Enable {
-		bridge.NewBridge("matterbot", bridge.NewConfig(*flagConfig), "legacy")
+			continue
+		}
+		fmt.Printf("starting samechannel gateway %#v\n", gw.Name)
+		go func(gw config.SameChannelGateway) {
+			err := samechannelgateway.New(cfg, &gw)
+			if err != nil {
+				log.Fatalf("starting gateway failed %#v", err)
+			}
+		}(gw)
+	}
+
+	for _, gw := range cfg.Gateway {
+		if !gw.Enable {
+			continue
+		}
+		fmt.Printf("starting gateway %#v\n", gw.Name)
+		g := gateway.New(cfg, &gw)
+		err := g.Start()
+		if err != nil {
+			log.Fatalf("starting gateway failed %#v", err)
+		}
 	}
 	select {}
 }

matterbridge.toml.sample

@@ -0,0 +1,579 @@
+#This is configuration for matterbridge.
+###################################################################
+#IRC section
+###################################################################
+#REQUIRED to start IRC section
+[irc]
+
+#You can configure multiple servers "[irc.name]" or "[irc.name2]"
+#In this example we use [irc.freenode]
+#REQUIRED
+[irc.freenode]
+#irc server to connect to. 
+#REQUIRED
+Server="irc.freenode.net:6667"
+
+#Password for irc server (if necessary)
+#OPTIONAL (default "")
+Password=""
+
+#Enable to use TLS connection to your irc server. 
+#OPTIONAL (default false)
+UseTLS=false
+
+#Enable SASL (PLAIN) authentication. (freenode requires this from eg AWS hosts)
+#It uses NickServNick and NickServPassword as login and password
+#OPTIONAL (default false)
+UseSASL=false
+
+#Enable to not verify the certificate on your irc server. i
+#e.g. when using selfsigned certificates
+#OPTIONAL (default false)
+SkipTLSVerify=true
+
+#Your nick on irc. 
+#REQUIRED
+Nick="matterbot"
+
+#If you registered your bot with a service like Nickserv on freenode. 
+#Also being used when UseSASL=true
+#OPTIONAL
+NickServNick="nickserv"
+NickServPassword="secret"
+
+#Flood control
+#Delay in milliseconds between each message send to the IRC server
+#OPTIONAL (default 1300)
+MessageDelay=1300
+
+#Maximum amount of messages to hold in queue. If queue is full 
+#messages will be dropped. 
+#<clipped> will be add to the message that fills the queue.
+#OPTIONAL (default 30)
+MessageQueue=30
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="ircspammer1 ircspammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+###################################################################
+#XMPP section
+###################################################################
+[xmpp]
+
+#You can configure multiple servers "[xmpp.name]" or "[xmpp.name2]"
+#In this example we use [xmpp.jabber]
+#REQUIRED
+[xmpp.jabber]
+#xmpp server to connect to. 
+#REQUIRED
+Server="jabber.example.com:5222"
+
+#Jid
+#REQUIRED
+Jid="user@example.com"
+
+#Password
+#REQUIRED
+Password="yourpass"
+
+#MUC
+#REQUIRED
+Muc="conference.jabber.example.com"
+
+#Your nick in the rooms
+#REQUIRED
+Nick="xmppbot"
+
+#Enable to not verify the certificate on your xmpp server.
+#e.g. when using selfsigned certificates
+#OPTIONAL (default false)
+SkipTLSVerify=true
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="ircspammer1 ircspammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+
+###################################################################
+#hipchat section
+###################################################################
+#Go to https://www.hipchat.com/account/xmpp this will show you the necessary data
+#to fill in the section below
+[xmpp.hipchat]
+#xmpp server to connect to. 
+#REQUIRED
+Server="chat.hipchat.com:5222"
+
+#Jabber ID
+#REQUIRED
+Jid="12345_12345@chat.hipchat.com"
+
+#Password (your hipchat password)
+#REQUIRED
+Password="yourpass"
+
+#Conference (MUC) domain
+#REQUIRED
+Muc="conf.hipchat.com"
+
+#Room nickname
+#REQUIRED
+Nick="yourlogin"
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="spammer1 spammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}/{BRIDGE}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+
+###################################################################
+#mattermost section
+###################################################################
+[mattermost]
+#You can configure multiple servers "[mattermost.name]" or "[mattermost.name2]"
+#In this example we use [mattermost.work]
+#REQUIRED
+
+[mattermost.work]
+#### Settings for webhook matterbridge.
+#### These settings will not be used when useAPI is enabled
+
+#Url is your incoming webhook url as specified in mattermost. 
+#See account settings - integrations - incoming webhooks on mattermost.
+#REQUIRED (unless useAPI=true)
+URL="https://yourdomain/hooks/yourhookkey"
+
+#Address to listen on for outgoing webhook requests from mattermost.
+#See account settings - integrations - outgoing webhooks on mattermost.
+#This setting will not be used when using -plus switch which doesn't use 
+#webhooks
+#REQUIRED (unless useAPI=true)
+BindAddress="0.0.0.0:9999"
+
+#Icon that will be showed in mattermost. 
+#OPTIONAL
+IconURL="http://youricon.png"
+
+#### Settings for matterbridge -plus
+#### Thse settings will only be used when using the -plus switch.
+
+#### Settings for using matterbridge API
+#OPTIONAL
+useAPI=false
+
+#The mattermost hostname. 
+#REQUIRED (when useAPI=true)
+Server="yourmattermostserver.domain"
+
+#Your team on mattermost. 
+#REQUIRED (when useAPI=true)
+Team="yourteam"
+
+#login/pass of your bot. 
+#Use a dedicated user for this and not your own! 
+#REQUIRED (when useAPI=true)
+Login="yourlogin"
+Password="yourpass"
+
+#Enable this to make a http connection (instead of https) to your mattermost. 
+#OPTIONAL (default false)
+NoTLS=false
+
+#### Shared settings for matterbridge and -plus
+
+#Enable to not verify the certificate on your mattermost server. 
+#e.g. when using selfsigned certificates
+#OPTIONAL (default false)
+SkipTLSVerify=true
+
+#how to format the list of IRC nicks when displayed in mattermost. 
+#Possible options are "table" and "plain"
+#OPTIONAL (default plain)
+NickFormatter="plain"
+#How many nicks to list per row for formatters that support this. 
+#OPTIONAL (default 4)
+NicksPerRow=4
+
+#Whether to prefix messages from other bridges to mattermost with the sender's nick. 
+#Useful if username overrides for incoming webhooks isn't enabled on the 
+#mattermost server. If you set PrefixMessagesWithNick to true, each message 
+#from bridge to Mattermost will by default be prefixed by "bridge-" + nick. You can, 
+#however, modify how the messages appear, by setting (and modifying) RemoteNickFormat 
+#OPTIONAL (default false)
+PrefixMessagesWithNick=false
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="ircspammer1 ircspammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+###################################################################
+#Gitter section
+#Best to make a dedicated gitter account for the bot.
+###################################################################
+
+[gitter]
+
+#You can configure multiple servers "[gitter.name]" or "[gitter.name2]"
+#In this example we use [gitter.myproject]
+#REQUIRED
+[gitter.myproject]
+#Token to connect with Gitter API
+#You can get your token by going to https://developer.gitter.im/docs/welcome and SIGN IN
+#REQUIRED
+Token="Yourtokenhere"
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="ircspammer1 ircspammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+###################################################################
+#slack section
+###################################################################
+[slack]
+
+#You can configure multiple servers "[slack.name]" or "[slack.name2]"
+#In this example we use [slack.hobby]
+#REQUIRED
+[slack.hobby]
+#### Settings for webhook matterbridge.
+#### These settings will not be used when useAPI is enabled
+
+#Url is your incoming webhook url as specified in slack
+#See account settings - integrations - incoming webhooks on slack
+#REQUIRED (unless useAPI=true)
+URL="https://hooks.slack.com/services/yourhook"
+
+#Address to listen on for outgoing webhook requests from slack
+#See account settings - integrations - outgoing webhooks on slack
+#This setting will not be used when useAPI is eanbled
+#webhooks
+#REQUIRED (unless useAPI=true)
+BindAddress="0.0.0.0:9999"
+
+#### Settings for using slack API
+#OPTIONAL
+useAPI=false
+
+#Token to connect with the Slack API
+#You'll have to use a test/api-token using a dedicated user and not a bot token.
+#See https://github.com/42wim/matterbridge/issues/75 for more info.
+#REQUIRED (when useAPI=true)
+Token="yourslacktoken"
+
+#### Shared settings for webhooks and API
+
+#Icon that will be showed in slack
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL
+IconURL="https://robohash.org/{NICK}.png?size=48x48"
+
+#how to format the list of IRC nicks when displayed in slack
+#Possible options are "table" and "plain"
+#OPTIONAL (default plain)
+NickFormatter="plain"
+#How many nicks to list per row for formatters that support this. 
+#OPTIONAL (default 4)
+NicksPerRow=4
+
+#Whether to prefix messages from other bridges to mattermost with RemoteNickFormat
+#Useful if username overrides for incoming webhooks isn't enabled on the 
+#slack server. If you set PrefixMessagesWithNick to true, each message 
+#from bridge to Slack will by default be prefixed by "bridge-" + nick. You can, 
+#however, modify how the messages appear, by setting (and modifying) RemoteNickFormat 
+#OPTIONAL (default false)
+PrefixMessagesWithNick=false
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="ircspammer1 ircspammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+###################################################################
+#discord section
+###################################################################
+[discord]
+
+#You can configure multiple servers "[discord.name]" or "[discord.name2]"
+#In this example we use [discord.game]
+#REQUIRED
+[discord.game]
+#Token to connect with Discord API
+#You can get your token by following the instructions on 
+#https://github.com/reactiflux/discord-irc/wiki/Creating-a-discord-bot-&-getting-a-token
+#REQUIRED
+Token="Yourtokenhere"
+
+#REQUIRED
+Server="yourservername"
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="ircspammer1 ircspammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+###################################################################
+#telegram section
+###################################################################
+[telegram]
+
+#You can configure multiple servers "[telegram.name]" or "[telegram.name2]"
+#In this example we use [telegram.secure]
+#REQUIRED
+[telegram.secure]
+#Token to connect with telegram API
+#See https://core.telegram.org/bots#6-botfather and https://www.linkedin.com/pulse/telegram-bots-beginners-marco-frau
+#REQUIRED
+Token="Yourtokenhere"
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="spammer1 spammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+
+###################################################################
+#rocketchat section
+###################################################################
+[rocketchat]
+#You can configure multiple servers "[rocketchat.name]" or "[rocketchat.name2]"
+#In this example we use [rocketchat.work]
+#REQUIRED
+
+[rocketchat.rockme]
+#Url is your incoming webhook url as specified in rocketchat
+#Read #https://rocket.chat/docs/administrator-guides/integrations/#how-to-create-a-new-incoming-webhook
+#See administration - integrations - new integration - incoming webhook
+#REQUIRED
+URL="https://yourdomain/hooks/yourhookkey"
+
+#Address to listen on for outgoing webhook requests from rocketchat.
+#See administration - integrations - new integration - outgoing webhook
+#REQUIRED 
+BindAddress="0.0.0.0:9999"
+
+#Your nick/username as specified in your incoming webhook "Post as" setting
+#REQUIRED
+Nick="matterbot"
+
+#Enable this to make a http connection (instead of https) to your rocketchat
+#OPTIONAL (default false)
+NoTLS=false
+
+#Enable to not verify the certificate on your rocketchat server. 
+#e.g. when using selfsigned certificates
+#OPTIONAL (default false)
+SkipTLSVerify=true
+
+#Whether to prefix messages from other bridges to rocketchat with the sender's nick. 
+#Useful if username overrides for incoming webhooks isn't enabled on the 
+#rocketchat server. If you set PrefixMessagesWithNick to true, each message 
+#from bridge to rocketchat will by default be prefixed by the RemoteNickFormat setting. i
+#OPTIONAL (default false)
+PrefixMessagesWithNick=false
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="ircspammer1 ircspammer2"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges (only from irc-bridge at the moment)
+#OPTIONAL (default false)
+ShowJoinPart=false
+
+
+###################################################################
+#General configuration
+###################################################################
+#Settings here override specific settings for each protocol
+[general]
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+###################################################################
+#Gateway configuration
+###################################################################
+
+#You can specify multiple gateways using [[gateway]]
+#Each gateway has a [[gateway.in]] and a [[gateway.out]]
+#[[gateway.in]] specifies the account and channels we will receive messages from.
+#[[gateway.out]] specifies the account and channels we will send the messages
+#from [[gateway.in]] to.
+#
+#Most of the time [[gateway.in]] and [[gateway.out]] are the same if you 
+#want bidirectional bridging. You can then use [[gateway.inout]]
+#
+
+[[gateway]]
+#OPTIONAL (not used for now)
+name="gateway1"
+#Enable enables this gateway
+##OPTIONAL (default false)
+enable=true
+
+    #[[gateway.in]] specifies the account and channels we will receive messages from.
+    #The following example bridges between mattermost and irc
+    [[gateway.in]]
+
+    #account specified above
+    #REQUIRED
+    account="irc.freenode"
+    #channel to connect on that account
+    #How to specify them for the different bridges:
+    #
+    #irc        - #channel (# is required)
+    #mattermost - channel (the channel name as seen in the URL, not the displayname)
+    #gitter     - username/room 
+    #xmpp       - channel
+    #slack      - channel (the channel name as seen in the URL, not the displayname)
+    #discord    - channel (without the #)
+    #           - ID:123456789 (where 123456789 is the channel ID) 
+    #               (https://github.com/42wim/matterbridge/issues/57)
+    #telegram   - chatid (a large negative number, eg -123456789)
+    #             see (https://www.linkedin.com/pulse/telegram-bots-beginners-marco-frau)
+    #hipchat    - id_channel (see https://www.hipchat.com/account/xmpp for the correct channel)
+    #rocketchat - #channel (# is required)
+    #REQUIRED
+    channel="#testing"
+
+        #OPTIONAL - only used for IRC protocol at the moment
+        [gateway.in.options]
+        #OPTIONAL - your irc channel key
+        key="yourkey"
+
+
+    #[[gateway.out]] specifies the account and channels we will sent messages to.
+    [[gateway.out]]
+    account="irc.freenode"
+    channel="#testing"
+
+        #OPTIONAL - only used for IRC protocol at the moment
+        [gateway.out.options]
+        #OPTIONAL - your irc channel key
+        key="yourkey"
+
+    #[[gateway.inout]] can be used when then channel will be used to receive from 
+    #and send messages to
+    [[gateway.inout]]
+    account="mattermost.work"
+    channel="off-topic"
+
+        #OPTIONAL - only used for IRC protocol at the moment
+        [gateway.inout.options]
+        #OPTIONAL - your irc channel key
+        key="yourkey"
+
+#If you want to do a 1:1 mapping between protocols where the channelnames are the same
+#e.g. slack and mattermost you can use the samechannelgateway configuration
+#the example configuration below send messages from channel testing on mattermost to
+#channel testing on slack and vice versa. (and for the channel testing2 and testing3)
+
+[[samechannelgateway]]
+   enable = false
+   accounts = [ "mattermost.work","slack.hobby" ]
+   channels = [ "testing","testing2","testing3"]

matterbridge.toml.simple

@@ -0,0 +1,32 @@
+[irc]
+    [irc.freenode]
+    Server="irc.freenode.net:6667"
+    Nick="matterbot"
+
+[mattermost]
+    [mattermost.work]
+    useAPI=true
+    Server="yourmattermostserver.domain"
+    Team="yourteam"
+    Login="yourlogin"
+    Password="yourpass"
+    PrefixMessagesWithNick=true
+
+[[gateway]]
+name="gateway1"
+enable=true
+    [[gateway.in]]
+    account="irc.freenode"
+    channel="#testing"
+
+    [[gateway.out]]
+    account="irc.freenode"
+    channel="#testing"
+
+    [[gateway.in]]
+    account="mattermost.work"
+    channel="off-topic"
+    
+    [[gateway.out]]
+    account="mattermost.work"
+    channel="off-topic"

matterclient/matterclient.go

@@ -2,6 +2,7 @@ package matterclient
 
 import (
 	"crypto/tls"
+	"encoding/json"
 	"errors"
 	"net/http"
 	"net/http/cookiejar"
@@ -27,7 +28,7 @@ type Credentials struct {
 }
 
 type Message struct {
-	Raw      *model.Message
+	Raw      *model.WebSocketEvent
 	Post     *model.Post
 	Team     string
 	Channel  string
@@ -49,14 +50,16 @@ type MMClient struct {
 	Team        *Team
 	OtherTeams  []*Team
 	Client      *model.Client
-	WsClient    *websocket.Conn
-	WsQuit      bool
-	WsAway      bool
-	WsConnected bool
 	User        *model.User
 	Users       map[string]*model.User
 	MessageChan chan *Message
 	log         *log.Entry
+	WsClient    *websocket.Conn
+	WsQuit      bool
+	WsAway      bool
+	WsConnected bool
+	WsSequence  int64
+	WsPingChan  chan *model.WebSocketResponse
 }
 
 func New(login, pass, team, server string) *MMClient {
@@ -77,6 +80,11 @@ func (m *MMClient) SetLogLevel(level string) {
 }
 
 func (m *MMClient) Login() error {
+	// check if this is a first connect or a reconnection
+	firstConnection := true
+	if m.WsConnected == true {
+		firstConnection = false
+	}
 	m.WsConnected = false
 	if m.WsQuit {
 		return nil
@@ -122,8 +130,7 @@ func (m *MMClient) Login() error {
 		if appErr != nil {
 			d := b.Duration()
 			m.log.Debug(appErr.DetailedError)
-			if !strings.Contains(appErr.DetailedError, "connection refused") &&
+			if firstConnection {
-				!strings.Contains(appErr.DetailedError, "invalid character") {
 				if appErr.Message == "" {
 					return errors.New(appErr.DetailedError)
 				}
@@ -151,7 +158,7 @@ func (m *MMClient) Login() error {
 	m.Client.SetTeamId(m.Team.Id)
 
 	// setup websocket connection
-	wsurl := wsScheme + m.Credentials.Server + "/api/v3/users/websocket"
+	wsurl := wsScheme + m.Credentials.Server + model.API_URL_SUFFIX + "/users/websocket"
 	header := http.Header{}
 	header.Set(model.HEADER_AUTH, "BEARER "+m.Client.AuthToken)
 
@@ -169,6 +176,8 @@ func (m *MMClient) Login() error {
 	}
 	b.Reset()
 
+	m.WsSequence = 1
+	m.WsPingChan = make(chan *model.WebSocketResponse)
 	// only start to parse WS messages when login is completely done
 	m.WsConnected = true
 
@@ -180,7 +189,6 @@ func (m *MMClient) Logout() error {
 	m.WsQuit = true
 	m.WsClient.Close()
 	m.WsClient.UnderlyingConn().Close()
-	m.WsClient = nil
 	_, err := m.Client.Logout()
 	if err != nil {
 		return err
@@ -190,42 +198,46 @@ func (m *MMClient) Logout() error {
 
 func (m *MMClient) WsReceiver() {
 	for {
-		var rmsg model.Message
+		var rawMsg json.RawMessage
+		var err error
+
 		if m.WsQuit {
 			m.log.Debug("exiting WsReceiver")
 			return
 		}
-		if err := m.WsClient.ReadJSON(&rmsg); err != nil {
+
+		if !m.WsConnected {
+			time.Sleep(time.Millisecond * 100)
+			continue
+		}
+
+		if _, rawMsg, err = m.WsClient.ReadMessage(); err != nil {
 			m.log.Error("error:", err)
 			// reconnect
 			m.Login()
 		}
-		// we're not fully logged in yet.
+
-		if !m.WsConnected {
+		var event model.WebSocketEvent
+		if err := json.Unmarshal(rawMsg, &event); err == nil && event.IsValid() {
+			m.log.Debugf("WsReceiver: %#v", event)
+			msg := &Message{Raw: &event, Team: m.Credentials.Team}
+			m.parseMessage(msg)
+			m.MessageChan <- msg
 			continue
 		}
-		if rmsg.Action == "ping" {
+
-			m.handleWsPing()
+		var response model.WebSocketResponse
+		if err := json.Unmarshal(rawMsg, &response); err == nil && response.IsValid() {
+			m.log.Debugf("WsReceiver: %#v", response)
+			m.parseResponse(response)
 			continue
 		}
-		msg := &Message{Raw: &rmsg, Team: m.Credentials.Team}
-		m.parseMessage(msg)
-		m.MessageChan <- msg
-	}
-
-}
-
-func (m *MMClient) handleWsPing() {
-	m.log.Debug("Ws PING")
-	if !m.WsQuit && !m.WsAway {
-		m.log.Debug("Ws PONG")
-		m.WsClient.WriteMessage(websocket.PongMessage, []byte{})
 	}
 }
 
 func (m *MMClient) parseMessage(rmsg *Message) {
-	switch rmsg.Raw.Action {
+	switch rmsg.Raw.Event {
-	case model.ACTION_POSTED:
+	case model.WEBSOCKET_EVENT_POSTED:
 		m.parseActionPost(rmsg)
 		/*
 			case model.ACTION_USER_REMOVED:
@@ -236,17 +248,26 @@ func (m *MMClient) parseMessage(rmsg *Message) {
 	}
 }
 
+func (m *MMClient) parseResponse(rmsg model.WebSocketResponse) {
+	if rmsg.Data != nil {
+		// ping reply
+		if rmsg.Data["text"].(string) == "pong" {
+			m.WsPingChan <- &rmsg
+		}
+	}
+}
+
 func (m *MMClient) parseActionPost(rmsg *Message) {
-	data := model.PostFromJson(strings.NewReader(rmsg.Raw.Props["post"]))
+	data := model.PostFromJson(strings.NewReader(rmsg.Raw.Data["post"].(string)))
 	// we don't have the user, refresh the userlist
 	if m.GetUser(data.UserId) == nil {
 		m.UpdateUsers()
 	}
 	rmsg.Username = m.GetUser(data.UserId).Username
 	rmsg.Channel = m.GetChannelName(data.ChannelId)
-	rmsg.Team = m.GetTeamName(rmsg.Raw.TeamId)
+	rmsg.Team = m.GetTeamName(rmsg.Raw.Data["team_id"].(string))
 	// direct message
-	if data.Type == "D" {
+	if rmsg.Raw.Data["channel_type"] == "D" {
 		rmsg.Channel = m.GetUser(data.UserId).Username
 	}
 	rmsg.Text = data.Message
@@ -255,7 +276,10 @@ func (m *MMClient) parseActionPost(rmsg *Message) {
 }
 
 func (m *MMClient) UpdateUsers() error {
-	mmusers, _ := m.Client.GetProfilesForDirectMessageList(m.Team.Id)
+	mmusers, err := m.Client.GetProfiles(0, 50000, "")
+	if err != nil {
+		return errors.New(err.DetailedError)
+	}
 	m.Lock()
 	m.Users = mmusers.Data.(map[string]*model.User)
 	m.Unlock()
@@ -263,8 +287,14 @@ func (m *MMClient) UpdateUsers() error {
 }
 
 func (m *MMClient) UpdateChannels() error {
-	mmchannels, _ := m.Client.GetChannels("")
+	mmchannels, err := m.Client.GetChannels("")
-	mmchannels2, _ := m.Client.GetMoreChannels("")
+	if err != nil {
+		return errors.New(err.DetailedError)
+	}
+	mmchannels2, err := m.Client.GetMoreChannels("")
+	if err != nil {
+		return errors.New(err.DetailedError)
+	}
 	m.Lock()
 	m.Team.Channels = mmchannels.Data.(*model.ChannelList)
 	m.Team.MoreChannels = mmchannels2.Data.(*model.ChannelList)
@@ -276,7 +306,7 @@ func (m *MMClient) GetChannelName(channelId string) string {
 	m.RLock()
 	defer m.RUnlock()
 	for _, t := range m.OtherTeams {
-		for _, channel := range append(t.Channels.Channels, t.MoreChannels.Channels...) {
+		for _, channel := range append(*t.Channels, *t.MoreChannels...) {
 			if channel.Id == channelId {
 				return channel.Name
 			}
@@ -293,7 +323,7 @@ func (m *MMClient) GetChannelId(name string, teamId string) string {
 	}
 	for _, t := range m.OtherTeams {
 		if t.Id == teamId {
-			for _, channel := range append(t.Channels.Channels, t.MoreChannels.Channels...) {
+			for _, channel := range append(*t.Channels, *t.MoreChannels...) {
 				if channel.Name == name {
 					return channel.Id
 				}
@@ -307,7 +337,7 @@ func (m *MMClient) GetChannelHeader(channelId string) string {
 	m.RLock()
 	defer m.RUnlock()
 	for _, t := range m.OtherTeams {
-		for _, channel := range append(t.Channels.Channels, t.MoreChannels.Channels...) {
+		for _, channel := range append(*t.Channels, *t.MoreChannels...) {
 			if channel.Id == channelId {
 				return channel.Header
 			}
@@ -325,7 +355,7 @@ func (m *MMClient) PostMessage(channelId string, text string) {
 func (m *MMClient) JoinChannel(channelId string) error {
 	m.RLock()
 	defer m.RUnlock()
-	for _, c := range m.Team.Channels.Channels {
+	for _, c := range *m.Team.Channels {
 		if c.Id == channelId {
 			m.log.Debug("Not joining ", channelId, " already joined.")
 			return nil
@@ -368,7 +398,7 @@ func (m *MMClient) GetPublicLink(filename string) string {
 	if err != nil {
 		return ""
 	}
-	return res.Data.(string)
+	return res
 }
 
 func (m *MMClient) GetPublicLinks(filenames []string) []string {
@@ -378,7 +408,7 @@ func (m *MMClient) GetPublicLinks(filenames []string) []string {
 		if err != nil {
 			continue
 		}
-		output = append(output, res.Data.(string))
+		output = append(output, res)
 	}
 	return output
 }
@@ -396,22 +426,24 @@ func (m *MMClient) UpdateChannelHeader(channelId string, header string) {
 
 func (m *MMClient) UpdateLastViewed(channelId string) {
 	m.log.Debugf("posting lastview %#v", channelId)
-	_, err := m.Client.UpdateLastViewedAt(channelId)
+	_, err := m.Client.UpdateLastViewedAt(channelId, true)
 	if err != nil {
 		m.log.Error(err)
 	}
 }
 
 func (m *MMClient) UsernamesInChannel(channelId string) []string {
-	ceiRes, err := m.Client.GetChannelExtraInfo(channelId, 5000, "")
+	res, err := m.Client.GetMyChannelMembers()
 	if err != nil {
 		m.log.Errorf("UsernamesInChannel(%s) failed: %s", channelId, err)
 		return []string{}
 	}
-	extra := ceiRes.Data.(*model.ChannelExtra)
+	members := res.Data.(*model.ChannelMembers)
 	result := []string{}
-	for _, member := range extra.Members {
+	for _, channel := range *members {
-		result = append(result, member.Username)
+		if channel.ChannelId == channelId {
+			result = append(result, m.GetUser(channel.UserId).Username)
+		}
 	}
 	return result
 }
@@ -471,10 +503,10 @@ func (m *MMClient) GetChannels() []*model.Channel {
 	defer m.RUnlock()
 	var channels []*model.Channel
 	// our primary team channels first
-	channels = append(channels, m.Team.Channels.Channels...)
+	channels = append(channels, *m.Team.Channels...)
 	for _, t := range m.OtherTeams {
 		if t.Id != m.Team.Id {
-			channels = append(channels, t.Channels.Channels...)
+			channels = append(channels, *t.Channels...)
 		}
 	}
 	return channels
@@ -486,7 +518,7 @@ func (m *MMClient) GetMoreChannels() []*model.Channel {
 	defer m.RUnlock()
 	var channels []*model.Channel
 	for _, t := range m.OtherTeams {
-		channels = append(channels, t.MoreChannels.Channels...)
+		channels = append(channels, *t.MoreChannels...)
 	}
 	return channels
 }
@@ -497,7 +529,8 @@ func (m *MMClient) GetTeamFromChannel(channelId string) string {
 	defer m.RUnlock()
 	var channels []*model.Channel
 	for _, t := range m.OtherTeams {
-		channels = append(channels, t.Channels.Channels...)
+		channels = append(channels, *t.Channels...)
+		channels = append(channels, *t.MoreChannels...)
 		for _, c := range channels {
 			if c.Id == channelId {
 				return t.Id
@@ -510,12 +543,12 @@ func (m *MMClient) GetTeamFromChannel(channelId string) string {
 func (m *MMClient) GetLastViewedAt(channelId string) int64 {
 	m.RLock()
 	defer m.RUnlock()
-	for _, t := range m.OtherTeams {
+	res, err := m.Client.GetChannel(channelId, "")
-		if _, ok := t.Channels.Members[channelId]; ok {
+	if err != nil {
-			return t.Channels.Members[channelId].LastViewedAt
+		return model.GetMillis()
-		}
 	}
-	return 0
+	data := res.Data.(*model.ChannelData)
+	return data.Member.LastViewedAt
 }
 
 func (m *MMClient) GetUsers() map[string]*model.User {
@@ -534,11 +567,71 @@ func (m *MMClient) GetUser(userId string) *model.User {
 	return m.Users[userId]
 }
 
+func (m *MMClient) GetStatus(userId string) string {
+	res, err := m.Client.GetStatuses()
+	if err != nil {
+		return ""
+	}
+	status := res.Data.(map[string]string)
+	if status[userId] == model.STATUS_AWAY {
+		return "away"
+	}
+	if status[userId] == model.STATUS_ONLINE {
+		return "online"
+	}
+	return "offline"
+}
+
+func (m *MMClient) GetStatuses() map[string]string {
+	var ok bool
+	statuses := make(map[string]string)
+	res, err := m.Client.GetStatuses()
+	if err != nil {
+		return statuses
+	}
+	if statuses, ok = res.Data.(map[string]string); ok {
+		for userId, status := range statuses {
+			statuses[userId] = "offline"
+			if status == model.STATUS_AWAY {
+				statuses[userId] = "away"
+			}
+			if status == model.STATUS_ONLINE {
+				statuses[userId] = "online"
+			}
+		}
+	}
+	return statuses
+}
+
+func (m *MMClient) GetTeamId() string {
+	return m.Team.Id
+}
+
+func (m *MMClient) StatusLoop() {
+	for {
+		if m.WsQuit {
+			return
+		}
+		if m.WsConnected {
+			m.log.Debug("WS PING")
+			m.sendWSRequest("ping", nil)
+			select {
+			case <-m.WsPingChan:
+				m.log.Debug("WS PONG received")
+			case <-time.After(time.Second * 5):
+				m.Logout()
+				m.WsQuit = false
+				m.Login()
+			}
+		}
+		time.Sleep(time.Second * 60)
+	}
+}
+
 // initialize user and teams
 func (m *MMClient) initUser() error {
 	m.Lock()
 	defer m.Unlock()
-	m.log.Debug("initUser()")
 	initLoad, err := m.Client.GetInitialLoad()
 	if err != nil {
 		return err
@@ -547,14 +640,23 @@ func (m *MMClient) initUser() error {
 	m.User = initData.User
 	// we only load all team data on initial login.
 	// all other updates are for channels from our (primary) team only.
-	m.log.Debug("initUser(): loading all team data")
+	//m.log.Debug("initUser(): loading all team data")
 	for _, v := range initData.Teams {
 		m.Client.SetTeamId(v.Id)
-		mmusers, _ := m.Client.GetProfiles(v.Id, "")
+		mmusers, err := m.Client.GetProfiles(0, 50000, "")
+		if err != nil {
+			return errors.New(err.DetailedError)
+		}
 		t := &Team{Team: v, Users: mmusers.Data.(map[string]*model.User), Id: v.Id}
-		mmchannels, _ := m.Client.GetChannels("")
+		mmchannels, err := m.Client.GetChannels("")
+		if err != nil {
+			return errors.New(err.DetailedError)
+		}
 		t.Channels = mmchannels.Data.(*model.ChannelList)
-		mmchannels, _ = m.Client.GetMoreChannels("")
+		mmchannels, err = m.Client.GetMoreChannels("")
+		if err != nil {
+			return errors.New(err.DetailedError)
+		}
 		t.MoreChannels = mmchannels.Data.(*model.ChannelList)
 		m.OtherTeams = append(m.OtherTeams, t)
 		if v.Name == m.Credentials.Team {
@@ -568,3 +670,14 @@ func (m *MMClient) initUser() error {
 	}
 	return nil
 }
+
+func (m *MMClient) sendWSRequest(action string, data map[string]interface{}) error {
+	req := &model.WebSocketRequest{}
+	req.Seq = m.WsSequence
+	req.Action = action
+	req.Data = data
+	m.WsSequence++
+	m.log.Debugf("sendWsRequest %#v", req)
+	m.WsClient.WriteJSON(req)
+	return nil
+}

matterhook/matterhook.go

@@ -27,6 +27,8 @@ type OMessage struct {
 
 // IMessage for mattermost outgoing webhook. (received from mattermost)
 type IMessage struct {
+	BotID       string `schema:"bot_id"`
+	BotName     string `schema:"bot_name"`
 	Token       string `schema:"token"`
 	TeamID      string `schema:"team_id"`
 	TeamDomain  string `schema:"team_domain"`
@@ -36,6 +38,8 @@ type IMessage struct {
 	UserID      string `schema:"user_id"`
 	UserName    string `schema:"user_name"`
 	PostId      string `schema:"post_id"`
+	RawText     string `schema:"raw_text"`
+	ServiceId   string `schema:"service_id"`
 	Text        string `schema:"text"`
 	TriggerWord string `schema:"trigger_word"`
 }

vendor/github.com/42wim/go-gitter/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/42wim/go-gitter/faye.go

@@ -0,0 +1,70 @@
+package gitter
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/mrexodia/wray"
+)
+
+type Faye struct {
+	endpoint string
+	Event    chan Event
+	client   *wray.FayeClient
+	gitter   *Gitter
+}
+
+func (gitter *Gitter) Faye(roomID string) *Faye {
+	wray.RegisterTransports([]wray.Transport{
+		&wray.HttpTransport{
+			SendHook: func(data map[string]interface{}) {
+				if channel, ok := data["channel"]; ok && channel == "/meta/handshake" {
+					data["ext"] = map[string]interface{}{"token": gitter.config.token}
+				}
+			},
+		},
+	})
+	return &Faye{
+		endpoint: "/api/v1/rooms/" + roomID + "/chatMessages",
+		Event:    make(chan Event),
+		client:   wray.NewFayeClient(fayeBaseURL),
+		gitter:   gitter,
+	}
+}
+
+func (faye *Faye) Listen() {
+	defer faye.destroy()
+
+	faye.client.Subscribe(faye.endpoint, false, func(message wray.Message) {
+		dataBytes, err := json.Marshal(message.Data["model"])
+		if err != nil {
+			fmt.Printf("JSON Marshal error: %v\n", err)
+			return
+		}
+		var gitterMessage Message
+		err = json.Unmarshal(dataBytes, &gitterMessage)
+		if err != nil {
+			fmt.Printf("JSON Unmarshal error: %v\n", err)
+			return
+		}
+		faye.Event <- Event{
+			Data: &MessageReceived{
+				Message: gitterMessage,
+			},
+		}
+	})
+
+	//TODO: this might be needed in the future
+	/*go func() {
+		for {
+			faye.client.Publish("/api/v1/ping2", map[string]interface{}{"reason": "ping"})
+			time.Sleep(60 * time.Second)
+		}
+	}()*/
+
+	faye.client.Listen()
+}
+
+func (faye *Faye) destroy() {
+	close(faye.Event)
+}

vendor/github.com/42wim/go-gitter/gitter.go

@@ -0,0 +1,430 @@
+// Package gitter is a Go client library for the Gitter API.
+//
+// Author: sromku
+package gitter
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"github.com/mreiferson/go-httpclient"
+)
+
+var (
+	apiBaseURL    = "https://api.gitter.im/v1/"
+	streamBaseURL = "https://stream.gitter.im/v1/"
+	fayeBaseURL   = "https://ws.gitter.im/faye"
+)
+
+type Gitter struct {
+	config struct {
+		apiBaseURL    string
+		streamBaseURL string
+		token         string
+		client        *http.Client
+	}
+	debug     bool
+	logWriter io.Writer
+}
+
+// New initializes the Gitter API client
+//
+// For example:
+//  api := gitter.New("YOUR_ACCESS_TOKEN")
+func New(token string) *Gitter {
+
+	transport := &httpclient.Transport{
+		ConnectTimeout:   5 * time.Second,
+		ReadWriteTimeout: 40 * time.Second,
+	}
+	defer transport.Close()
+
+	s := &Gitter{}
+	s.config.apiBaseURL = apiBaseURL
+	s.config.streamBaseURL = streamBaseURL
+	s.config.token = token
+	s.config.client = &http.Client{
+		Transport: transport,
+	}
+	return s
+}
+
+// SetClient sets a custom http client. Can be useful in App Engine case.
+func (gitter *Gitter) SetClient(client *http.Client) {
+	gitter.config.client = client
+}
+
+// GetUser returns the current user
+func (gitter *Gitter) GetUser() (*User, error) {
+
+	var users []User
+	response, err := gitter.get(gitter.config.apiBaseURL + "user")
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &users)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	if len(users) > 0 {
+		return &users[0], nil
+	}
+
+	err = APIError{What: "Failed to retrieve current user"}
+	gitter.log(err)
+	return nil, err
+}
+
+// GetUserRooms returns a list of Rooms the user is part of
+func (gitter *Gitter) GetUserRooms(userID string) ([]Room, error) {
+
+	var rooms []Room
+	response, err := gitter.get(gitter.config.apiBaseURL + "user/" + userID + "/rooms")
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &rooms)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return rooms, nil
+}
+
+// GetRooms returns a list of rooms the current user is in
+func (gitter *Gitter) GetRooms() ([]Room, error) {
+
+	var rooms []Room
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms")
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &rooms)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return rooms, nil
+}
+
+// GetUsersInRoom returns the users in the room with the passed id
+func (gitter *Gitter) GetUsersInRoom(roomID string) ([]User, error) {
+
+	var users []User
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID + "/users")
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &users)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	return users, nil
+}
+
+// GetRoom returns a room with the passed id
+func (gitter *Gitter) GetRoom(roomID string) (*Room, error) {
+
+	var room Room
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &room)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return &room, nil
+}
+
+// GetMessages returns a list of messages in a room.
+// Pagination is optional. You can pass nil or specific pagination params.
+func (gitter *Gitter) GetMessages(roomID string, params *Pagination) ([]Message, error) {
+
+	var messages []Message
+	url := gitter.config.apiBaseURL + "rooms/" + roomID + "/chatMessages"
+	if params != nil {
+		url += "?" + params.encode()
+	}
+	response, err := gitter.get(url)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &messages)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return messages, nil
+}
+
+// GetMessage returns a message in a room.
+func (gitter *Gitter) GetMessage(roomID, messageID string) (*Message, error) {
+
+	var message Message
+	response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID + "/chatMessages/" + messageID)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(response, &message)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return &message, nil
+}
+
+// SendMessage sends a message to a room
+func (gitter *Gitter) SendMessage(roomID, text string) error {
+
+	message := Message{Text: text}
+	body, _ := json.Marshal(message)
+	_, err := gitter.post(gitter.config.apiBaseURL+"rooms/"+roomID+"/chatMessages", body)
+	if err != nil {
+		gitter.log(err)
+		return err
+	}
+
+	return nil
+}
+
+// JoinRoom joins a room
+func (gitter *Gitter) JoinRoom(roomID, userID string) (*Room, error) {
+
+	message := Room{ID: roomID}
+	body, _ := json.Marshal(message)
+	response, err := gitter.post(gitter.config.apiBaseURL+"user/"+userID+"/rooms", body)
+
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	var room Room
+	err = json.Unmarshal(response, &room)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return &room, nil
+}
+
+// LeaveRoom removes a user from the room
+func (gitter *Gitter) LeaveRoom(roomID, userID string) error {
+
+	_, err := gitter.delete(gitter.config.apiBaseURL + "rooms/" + roomID + "/users/" + userID)
+	if err != nil {
+		gitter.log(err)
+		return err
+	}
+
+	return nil
+}
+
+// SetDebug traces errors if it's set to true.
+func (gitter *Gitter) SetDebug(debug bool, logWriter io.Writer) {
+	gitter.debug = debug
+	gitter.logWriter = logWriter
+}
+
+// Pagination params
+type Pagination struct {
+
+	// Skip n messages
+	Skip int
+
+	// Get messages before beforeId
+	BeforeID string
+
+	// Get messages after afterId
+	AfterID string
+
+	// Maximum number of messages to return
+	Limit int
+
+	// Search query
+	Query string
+}
+
+func (messageParams *Pagination) encode() string {
+	values := url.Values{}
+
+	if messageParams.AfterID != "" {
+		values.Add("afterId", messageParams.AfterID)
+	}
+
+	if messageParams.BeforeID != "" {
+		values.Add("beforeId", messageParams.BeforeID)
+	}
+
+	if messageParams.Skip > 0 {
+		values.Add("skip", strconv.Itoa(messageParams.Skip))
+	}
+
+	if messageParams.Limit > 0 {
+		values.Add("limit", strconv.Itoa(messageParams.Limit))
+	}
+
+	return values.Encode()
+}
+
+func (gitter *Gitter) getResponse(url string, stream *Stream) (*http.Response, error) {
+	r, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	r.Header.Set("Content-Type", "application/json")
+	r.Header.Set("Accept", "application/json")
+	r.Header.Set("Authorization", "Bearer "+gitter.config.token)
+	if stream != nil {
+		stream.streamConnection.request = r
+	}
+	response, err := gitter.config.client.Do(r)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	return response, nil
+}
+
+func (gitter *Gitter) get(url string) ([]byte, error) {
+	resp, err := gitter.getResponse(url, nil)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)}
+		gitter.log(err)
+		return nil, err
+	}
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return body, nil
+}
+
+func (gitter *Gitter) post(url string, body []byte) ([]byte, error) {
+	r, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	r.Header.Set("Content-Type", "application/json")
+	r.Header.Set("Accept", "application/json")
+	r.Header.Set("Authorization", "Bearer "+gitter.config.token)
+
+	resp, err := gitter.config.client.Do(r)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)}
+		gitter.log(err)
+		return nil, err
+	}
+
+	result, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (gitter *Gitter) delete(url string) ([]byte, error) {
+	r, err := http.NewRequest("delete", url, nil)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	r.Header.Set("Content-Type", "application/json")
+	r.Header.Set("Accept", "application/json")
+	r.Header.Set("Authorization", "Bearer "+gitter.config.token)
+
+	resp, err := gitter.config.client.Do(r)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)}
+		gitter.log(err)
+		return nil, err
+	}
+
+	result, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		gitter.log(err)
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (gitter *Gitter) log(a interface{}) {
+	if gitter.debug {
+		log.Println(a)
+		if gitter.logWriter != nil {
+			timestamp := time.Now().Format(time.RFC3339)
+			msg := fmt.Sprintf("%v: %v", timestamp, a)
+			fmt.Fprintln(gitter.logWriter, msg)
+		}
+	}
+}
+
+// APIError holds data of errors returned from the API.
+type APIError struct {
+	What string
+}
+
+func (e APIError) Error() string {
+	return fmt.Sprintf("%v", e.What)
+}

vendor/github.com/42wim/go-gitter/model.go

@@ -0,0 +1,142 @@
+package gitter
+
+import "time"
+
+// A Room in Gitter can represent a GitHub Organization, a GitHub Repository, a Gitter Channel or a One-to-one conversation.
+// In the case of the Organizations and Repositories, the access control policies are inherited from GitHub.
+type Room struct {
+
+	// Room ID
+	ID string `json:"id"`
+
+	// Room name
+	Name string `json:"name"`
+
+	// Room topic. (default: GitHub repo description)
+	Topic string `json:"topic"`
+
+	// Room URI on Gitter
+	URI string `json:"uri"`
+
+	// Indicates if the room is a one-to-one chat
+	OneToOne bool `json:"oneToOne"`
+
+	// Count of users in the room
+	UserCount int `json:"userCount"`
+
+	// Number of unread messages for the current user
+	UnreadItems int `json:"unreadItems"`
+
+	// Number of unread mentions for the current user
+	Mentions int `json:"mentions"`
+
+	// Last time the current user accessed the room in ISO format
+	LastAccessTime time.Time `json:"lastAccessTime"`
+
+	// Indicates if the current user has disabled notifications
+	Lurk bool `json:"lurk"`
+
+	// Path to the room on gitter
+	URL string `json:"url"`
+
+	// Type of the room
+	// - ORG: A room that represents a GitHub Organization.
+	// - REPO: A room that represents a GitHub Repository.
+	// - ONETOONE: A one-to-one chat.
+	// - ORG_CHANNEL: A Gitter channel nested under a GitHub Organization.
+	// - REPO_CHANNEL A Gitter channel nested under a GitHub Repository.
+	// - USER_CHANNEL A Gitter channel nested under a GitHub User.
+	GithubType string `json:"githubType"`
+
+	// Tags that define the room
+	Tags []string `json:"tags"`
+
+	RoomMember bool `json:"roomMember"`
+
+	// Room version.
+	Version int `json:"v"`
+}
+
+type User struct {
+
+	// Gitter User ID
+	ID string `json:"id"`
+
+	// Gitter/GitHub username
+	Username string `json:"username"`
+
+	// Gitter/GitHub user real name
+	DisplayName string `json:"displayName"`
+
+	// Path to the user on Gitter
+	URL string `json:"url"`
+
+	// User avatar URI (small)
+	AvatarURLSmall string `json:"avatarUrlSmall"`
+
+	// User avatar URI (medium)
+	AvatarURLMedium string `json:"avatarUrlMedium"`
+}
+
+type Message struct {
+
+	// ID of the message
+	ID string `json:"id"`
+
+	// Original message in plain-text/markdown
+	Text string `json:"text"`
+
+	// HTML formatted message
+	HTML string `json:"html"`
+
+	// ISO formatted date of the message
+	Sent time.Time `json:"sent"`
+
+	// ISO formatted date of the message if edited
+	EditedAt time.Time `json:"editedAt"`
+
+	// User that sent the message
+	From User `json:"fromUser"`
+
+	// Boolean that indicates if the current user has read the message.
+	Unread bool `json:"unread"`
+
+	// Number of users that have read the message
+	ReadBy int `json:"readBy"`
+
+	// List of URLs present in the message
+	Urls []URL `json:"urls"`
+
+	// List of @Mentions in the message
+	Mentions []Mention `json:"mentions"`
+
+	// List of #Issues referenced in the message
+	Issues []Issue `json:"issues"`
+
+	// Version
+	Version int `json:"v"`
+}
+
+// Mention holds data about mentioned user in the message
+type Mention struct {
+
+	// User's username
+	ScreenName string `json:"screenName"`
+
+	// Gitter User ID
+	UserID string `json:"userID"`
+}
+
+// Issue references issue in the message
+type Issue struct {
+
+	// Issue number
+	Number string `json:"number"`
+}
+
+// URL presented in the message
+type URL struct {
+
+	// URL
+	URL string `json:"url"`
+}

vendor/github.com/42wim/go-gitter/stream.go

@@ -0,0 +1,221 @@
+package gitter
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/mreiferson/go-httpclient"
+)
+
+var defaultConnectionWaitTime time.Duration = 3000 // millis
+var defaultConnectionMaxRetries = 5
+
+// Stream initialize stream
+func (gitter *Gitter) Stream(roomID string) *Stream {
+	return &Stream{
+		url:    streamBaseURL + "rooms/" + roomID + "/chatMessages",
+		Event:  make(chan Event),
+		gitter: gitter,
+		streamConnection: gitter.newStreamConnection(
+			defaultConnectionWaitTime,
+			defaultConnectionMaxRetries),
+	}
+}
+
+// Implemented to conform with https://developer.gitter.im/docs/streaming-api
+func (gitter *Gitter) Listen(stream *Stream) {
+
+	defer stream.destroy()
+
+	var reader *bufio.Reader
+	var gitterMessage Message
+	lastKeepalive := time.Now().Unix()
+
+	// connect
+	stream.connect()
+
+Loop:
+	for {
+
+		// if closed then stop trying
+		if stream.isClosed() {
+			stream.Event <- Event{
+				Data: &GitterConnectionClosed{},
+			}
+			break Loop
+		}
+
+		resp := stream.getResponse()
+		if resp.StatusCode != 200 {
+			gitter.log(fmt.Sprintf("Unexpected response code %v", resp.StatusCode))
+			continue
+		}
+
+		//"The JSON stream returns messages as JSON objects that are delimited by carriage return (\r)" <- Not true crap it's (\n) only
+		reader = bufio.NewReader(resp.Body)
+		line, err := reader.ReadBytes('\n')
+		if err != nil {
+			gitter.log("ReadBytes error: " + err.Error())
+			stream.connect()
+			continue
+		}
+
+		//Check if the line only consists of whitespace
+		onlyWhitespace := true
+		for _, b := range line {
+			if b != ' ' && b != '\t' && b != '\r' && b != '\n' {
+				onlyWhitespace = false
+			}
+		}
+
+		if onlyWhitespace {
+			//"Parsers must be tolerant of occasional extra newline characters placed between messages."
+			currentKeepalive := time.Now().Unix() //interesting behavior of 100+ keepalives per seconds was observed
+			if currentKeepalive-lastKeepalive > 10 {
+				lastKeepalive = currentKeepalive
+				gitter.log("Keepalive was received")
+			}
+			continue
+		} else if stream.isClosed() {
+			gitter.log("Stream closed")
+			continue
+		}
+
+		// unmarshal the streamed data
+		err = json.Unmarshal(line, &gitterMessage)
+		if err != nil {
+			gitter.log("JSON Unmarshal error: " + err.Error())
+			continue
+		}
+
+		// we are here, then we got the good message. pipe it forward.
+		stream.Event <- Event{
+			Data: &MessageReceived{
+				Message: gitterMessage,
+			},
+		}
+	}
+
+	gitter.log("Listening was completed")
+}
+
+// Stream holds stream data.
+type Stream struct {
+	url              string
+	Event            chan Event
+	streamConnection *streamConnection
+	gitter           *Gitter
+}
+
+func (stream *Stream) destroy() {
+	close(stream.Event)
+}
+
+type Event struct {
+	Data interface{}
+}
+
+type GitterConnectionClosed struct {
+}
+
+type MessageReceived struct {
+	Message Message
+}
+
+// connect and try to reconnect with
+func (stream *Stream) connect() {
+
+	if stream.streamConnection.retries == stream.streamConnection.currentRetries {
+		stream.Close()
+		stream.gitter.log("Number of retries exceeded the max retries number, we are done here")
+		return
+	}
+
+	res, err := stream.gitter.getResponse(stream.url, stream)
+	if stream.streamConnection.canceled {
+		// do nothing
+	} else if err != nil || res.StatusCode != 200 {
+		stream.gitter.log("Failed to get response, trying reconnect ")
+		stream.gitter.log(err)
+
+		// sleep and wait
+		stream.streamConnection.currentRetries++
+		time.Sleep(time.Millisecond * stream.streamConnection.wait * time.Duration(stream.streamConnection.currentRetries))
+
+		// connect again
+		stream.Close()
+		stream.connect()
+	} else {
+		stream.gitter.log("Response was received")
+		stream.streamConnection.currentRetries = 0
+		stream.streamConnection.closed = false
+		stream.streamConnection.response = res
+	}
+}
+
+type streamConnection struct {
+
+	// connection was closed
+	closed bool
+
+	// canceled
+	canceled bool
+
+	// wait time till next try
+	wait time.Duration
+
+	// max tries to recover
+	retries int
+
+	// current streamed response
+	response *http.Response
+
+	// current request
+	request *http.Request
+
+	// current status
+	currentRetries int
+}
+
+// Close the stream connection and stop receiving streamed data
+func (stream *Stream) Close() {
+	conn := stream.streamConnection
+	conn.closed = true
+	if conn.response != nil {
+		stream.gitter.log("Stream connection close response")
+		defer conn.response.Body.Close()
+	}
+	if conn.request != nil {
+		stream.gitter.log("Stream connection close request")
+		switch transport := stream.gitter.config.client.Transport.(type) {
+		case *httpclient.Transport:
+			stream.streamConnection.canceled = true
+			transport.CancelRequest(conn.request)
+		default:
+		}
+
+	}
+	conn.currentRetries = 0
+}
+
+func (stream *Stream) isClosed() bool {
+	return stream.streamConnection.closed
+}
+
+func (stream *Stream) getResponse() *http.Response {
+	return stream.streamConnection.response
+}
+
+// Optional, set stream connection properties
+// wait - time in milliseconds of waiting between reconnections. Will grow exponentially.
+// retries - number of reconnections retries before dropping the stream.
+func (gitter *Gitter) newStreamConnection(wait time.Duration, retries int) *streamConnection {
+	return &streamConnection{
+		closed:  true,
+		wait:    wait,
+		retries: retries,
+	}
+}

vendor/github.com/42wim/go-gitter/test_utils.go

@@ -0,0 +1,30 @@
+package gitter
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+)
+
+var (
+	mux    *http.ServeMux
+	gitter *Gitter
+	server *httptest.Server
+)
+
+func setup() {
+	mux = http.NewServeMux()
+	server = httptest.NewServer(mux)
+
+	gitter = New("abc")
+
+	// Fake the API and Stream base URLs by using the test
+	// server URL instead.
+	url, _ := url.Parse(server.URL)
+	gitter.config.apiBaseURL = url.String() + "/"
+	gitter.config.streamBaseURL = url.String() + "/"
+}
+
+func teardown() {
+	server.Close()
+}

vendor/github.com/BurntSushi/toml/COPYING

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

vendor/github.com/BurntSushi/toml/cmd/toml-test-decoder/main.go

@@ -0,0 +1,90 @@
+// Command toml-test-decoder satisfies the toml-test interface for testing
+// TOML decoders. Namely, it accepts TOML on stdin and outputs JSON on stdout.
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"path"
+	"time"
+
+	"github.com/BurntSushi/toml"
+)
+
+func init() {
+	log.SetFlags(0)
+
+	flag.Usage = usage
+	flag.Parse()
+}
+
+func usage() {
+	log.Printf("Usage: %s < toml-file\n", path.Base(os.Args[0]))
+	flag.PrintDefaults()
+
+	os.Exit(1)
+}
+
+func main() {
+	if flag.NArg() != 0 {
+		flag.Usage()
+	}
+
+	var tmp interface{}
+	if _, err := toml.DecodeReader(os.Stdin, &tmp); err != nil {
+		log.Fatalf("Error decoding TOML: %s", err)
+	}
+
+	typedTmp := translate(tmp)
+	if err := json.NewEncoder(os.Stdout).Encode(typedTmp); err != nil {
+		log.Fatalf("Error encoding JSON: %s", err)
+	}
+}
+
+func translate(tomlData interface{}) interface{} {
+	switch orig := tomlData.(type) {
+	case map[string]interface{}:
+		typed := make(map[string]interface{}, len(orig))
+		for k, v := range orig {
+			typed[k] = translate(v)
+		}
+		return typed
+	case []map[string]interface{}:
+		typed := make([]map[string]interface{}, len(orig))
+		for i, v := range orig {
+			typed[i] = translate(v).(map[string]interface{})
+		}
+		return typed
+	case []interface{}:
+		typed := make([]interface{}, len(orig))
+		for i, v := range orig {
+			typed[i] = translate(v)
+		}
+
+		// We don't really need to tag arrays, but let's be future proof.
+		// (If TOML ever supports tuples, we'll need this.)
+		return tag("array", typed)
+	case time.Time:
+		return tag("datetime", orig.Format("2006-01-02T15:04:05Z"))
+	case bool:
+		return tag("bool", fmt.Sprintf("%v", orig))
+	case int64:
+		return tag("integer", fmt.Sprintf("%d", orig))
+	case float64:
+		return tag("float", fmt.Sprintf("%v", orig))
+	case string:
+		return tag("string", orig)
+	}
+
+	panic(fmt.Sprintf("Unknown type: %T", tomlData))
+}
+
+func tag(typeName string, data interface{}) map[string]interface{} {
+	return map[string]interface{}{
+		"type":  typeName,
+		"value": data,
+	}
+}

vendor/github.com/BurntSushi/toml/cmd/toml-test-encoder/main.go

@@ -0,0 +1,131 @@
+// Command toml-test-encoder satisfies the toml-test interface for testing
+// TOML encoders. Namely, it accepts JSON on stdin and outputs TOML on stdout.
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"log"
+	"os"
+	"path"
+	"strconv"
+	"time"
+
+	"github.com/BurntSushi/toml"
+)
+
+func init() {
+	log.SetFlags(0)
+
+	flag.Usage = usage
+	flag.Parse()
+}
+
+func usage() {
+	log.Printf("Usage: %s < json-file\n", path.Base(os.Args[0]))
+	flag.PrintDefaults()
+
+	os.Exit(1)
+}
+
+func main() {
+	if flag.NArg() != 0 {
+		flag.Usage()
+	}
+
+	var tmp interface{}
+	if err := json.NewDecoder(os.Stdin).Decode(&tmp); err != nil {
+		log.Fatalf("Error decoding JSON: %s", err)
+	}
+
+	tomlData := translate(tmp)
+	if err := toml.NewEncoder(os.Stdout).Encode(tomlData); err != nil {
+		log.Fatalf("Error encoding TOML: %s", err)
+	}
+}
+
+func translate(typedJson interface{}) interface{} {
+	switch v := typedJson.(type) {
+	case map[string]interface{}:
+		if len(v) == 2 && in("type", v) && in("value", v) {
+			return untag(v)
+		}
+		m := make(map[string]interface{}, len(v))
+		for k, v2 := range v {
+			m[k] = translate(v2)
+		}
+		return m
+	case []interface{}:
+		tabArray := make([]map[string]interface{}, len(v))
+		for i := range v {
+			if m, ok := translate(v[i]).(map[string]interface{}); ok {
+				tabArray[i] = m
+			} else {
+				log.Fatalf("JSON arrays may only contain objects. This " +
+					"corresponds to only tables being allowed in " +
+					"TOML table arrays.")
+			}
+		}
+		return tabArray
+	}
+	log.Fatalf("Unrecognized JSON format '%T'.", typedJson)
+	panic("unreachable")
+}
+
+func untag(typed map[string]interface{}) interface{} {
+	t := typed["type"].(string)
+	v := typed["value"]
+	switch t {
+	case "string":
+		return v.(string)
+	case "integer":
+		v := v.(string)
+		n, err := strconv.Atoi(v)
+		if err != nil {
+			log.Fatalf("Could not parse '%s' as integer: %s", v, err)
+		}
+		return n
+	case "float":
+		v := v.(string)
+		f, err := strconv.ParseFloat(v, 64)
+		if err != nil {
+			log.Fatalf("Could not parse '%s' as float64: %s", v, err)
+		}
+		return f
+	case "datetime":
+		v := v.(string)
+		t, err := time.Parse("2006-01-02T15:04:05Z", v)
+		if err != nil {
+			log.Fatalf("Could not parse '%s' as a datetime: %s", v, err)
+		}
+		return t
+	case "bool":
+		v := v.(string)
+		switch v {
+		case "true":
+			return true
+		case "false":
+			return false
+		}
+		log.Fatalf("Could not parse '%s' as a boolean.", v)
+	case "array":
+		v := v.([]interface{})
+		array := make([]interface{}, len(v))
+		for i := range v {
+			if m, ok := v[i].(map[string]interface{}); ok {
+				array[i] = untag(m)
+			} else {
+				log.Fatalf("Arrays may only contain other arrays or "+
+					"primitive values, but found a '%T'.", m)
+			}
+		}
+		return array
+	}
+	log.Fatalf("Unrecognized tag type '%s'.", t)
+	panic("unreachable")
+}
+
+func in(key string, m map[string]interface{}) bool {
+	_, ok := m[key]
+	return ok
+}

vendor/github.com/BurntSushi/toml/cmd/tomlv/main.go

@@ -0,0 +1,61 @@
+// Command tomlv validates TOML documents and prints each key's type.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"path"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/BurntSushi/toml"
+)
+
+var (
+	flagTypes = false
+)
+
+func init() {
+	log.SetFlags(0)
+
+	flag.BoolVar(&flagTypes, "types", flagTypes,
+		"When set, the types of every defined key will be shown.")
+
+	flag.Usage = usage
+	flag.Parse()
+}
+
+func usage() {
+	log.Printf("Usage: %s toml-file [ toml-file ... ]\n",
+		path.Base(os.Args[0]))
+	flag.PrintDefaults()
+
+	os.Exit(1)
+}
+
+func main() {
+	if flag.NArg() < 1 {
+		flag.Usage()
+	}
+	for _, f := range flag.Args() {
+		var tmp interface{}
+		md, err := toml.DecodeFile(f, &tmp)
+		if err != nil {
+			log.Fatalf("Error in '%s': %s", f, err)
+		}
+		if flagTypes {
+			printTypes(md)
+		}
+	}
+}
+
+func printTypes(md toml.MetaData) {
+	tabw := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+	for _, key := range md.Keys() {
+		fmt.Fprintf(tabw, "%s%s\t%s\n",
+			strings.Repeat("    ", len(key)-1), key, md.Type(key...))
+	}
+	tabw.Flush()
+}

vendor/github.com/BurntSushi/toml/decode.go

@@ -0,0 +1,509 @@
+package toml
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"reflect"
+	"strings"
+	"time"
+)
+
+func e(format string, args ...interface{}) error {
+	return fmt.Errorf("toml: "+format, args...)
+}
+
+// Unmarshaler is the interface implemented by objects that can unmarshal a
+// TOML description of themselves.
+type Unmarshaler interface {
+	UnmarshalTOML(interface{}) error
+}
+
+// Unmarshal decodes the contents of `p` in TOML format into a pointer `v`.
+func Unmarshal(p []byte, v interface{}) error {
+	_, err := Decode(string(p), v)
+	return err
+}
+
+// Primitive is a TOML value that hasn't been decoded into a Go value.
+// When using the various `Decode*` functions, the type `Primitive` may
+// be given to any value, and its decoding will be delayed.
+//
+// A `Primitive` value can be decoded using the `PrimitiveDecode` function.
+//
+// The underlying representation of a `Primitive` value is subject to change.
+// Do not rely on it.
+//
+// N.B. Primitive values are still parsed, so using them will only avoid
+// the overhead of reflection. They can be useful when you don't know the
+// exact type of TOML data until run time.
+type Primitive struct {
+	undecoded interface{}
+	context   Key
+}
+
+// DEPRECATED!
+//
+// Use MetaData.PrimitiveDecode instead.
+func PrimitiveDecode(primValue Primitive, v interface{}) error {
+	md := MetaData{decoded: make(map[string]bool)}
+	return md.unify(primValue.undecoded, rvalue(v))
+}
+
+// PrimitiveDecode is just like the other `Decode*` functions, except it
+// decodes a TOML value that has already been parsed. Valid primitive values
+// can *only* be obtained from values filled by the decoder functions,
+// including this method. (i.e., `v` may contain more `Primitive`
+// values.)
+//
+// Meta data for primitive values is included in the meta data returned by
+// the `Decode*` functions with one exception: keys returned by the Undecoded
+// method will only reflect keys that were decoded. Namely, any keys hidden
+// behind a Primitive will be considered undecoded. Executing this method will
+// update the undecoded keys in the meta data. (See the example.)
+func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {
+	md.context = primValue.context
+	defer func() { md.context = nil }()
+	return md.unify(primValue.undecoded, rvalue(v))
+}
+
+// Decode will decode the contents of `data` in TOML format into a pointer
+// `v`.
+//
+// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be
+// used interchangeably.)
+//
+// TOML arrays of tables correspond to either a slice of structs or a slice
+// of maps.
+//
+// TOML datetimes correspond to Go `time.Time` values.
+//
+// All other TOML types (float, string, int, bool and array) correspond
+// to the obvious Go types.
+//
+// An exception to the above rules is if a type implements the
+// encoding.TextUnmarshaler interface. In this case, any primitive TOML value
+// (floats, strings, integers, booleans and datetimes) will be converted to
+// a byte string and given to the value's UnmarshalText method. See the
+// Unmarshaler example for a demonstration with time duration strings.
+//
+// Key mapping
+//
+// TOML keys can map to either keys in a Go map or field names in a Go
+// struct. The special `toml` struct tag may be used to map TOML keys to
+// struct fields that don't match the key name exactly. (See the example.)
+// A case insensitive match to struct names will be tried if an exact match
+// can't be found.
+//
+// The mapping between TOML values and Go values is loose. That is, there
+// may exist TOML values that cannot be placed into your representation, and
+// there may be parts of your representation that do not correspond to
+// TOML values. This loose mapping can be made stricter by using the IsDefined
+// and/or Undecoded methods on the MetaData returned.
+//
+// This decoder will not handle cyclic types. If a cyclic type is passed,
+// `Decode` will not terminate.
+func Decode(data string, v interface{}) (MetaData, error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Ptr {
+		return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v))
+	}
+	if rv.IsNil() {
+		return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v))
+	}
+	p, err := parse(data)
+	if err != nil {
+		return MetaData{}, err
+	}
+	md := MetaData{
+		p.mapping, p.types, p.ordered,
+		make(map[string]bool, len(p.ordered)), nil,
+	}
+	return md, md.unify(p.mapping, indirect(rv))
+}
+
+// DecodeFile is just like Decode, except it will automatically read the
+// contents of the file at `fpath` and decode it for you.
+func DecodeFile(fpath string, v interface{}) (MetaData, error) {
+	bs, err := ioutil.ReadFile(fpath)
+	if err != nil {
+		return MetaData{}, err
+	}
+	return Decode(string(bs), v)
+}
+
+// DecodeReader is just like Decode, except it will consume all bytes
+// from the reader and decode it for you.
+func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
+	bs, err := ioutil.ReadAll(r)
+	if err != nil {
+		return MetaData{}, err
+	}
+	return Decode(string(bs), v)
+}
+
+// unify performs a sort of type unification based on the structure of `rv`,
+// which is the client representation.
+//
+// Any type mismatch produces an error. Finding a type that we don't know
+// how to handle produces an unsupported type error.
+func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
+
+	// Special case. Look for a `Primitive` value.
+	if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() {
+		// Save the undecoded data and the key context into the primitive
+		// value.
+		context := make(Key, len(md.context))
+		copy(context, md.context)
+		rv.Set(reflect.ValueOf(Primitive{
+			undecoded: data,
+			context:   context,
+		}))
+		return nil
+	}
+
+	// Special case. Unmarshaler Interface support.
+	if rv.CanAddr() {
+		if v, ok := rv.Addr().Interface().(Unmarshaler); ok {
+			return v.UnmarshalTOML(data)
+		}
+	}
+
+	// Special case. Handle time.Time values specifically.
+	// TODO: Remove this code when we decide to drop support for Go 1.1.
+	// This isn't necessary in Go 1.2 because time.Time satisfies the encoding
+	// interfaces.
+	if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) {
+		return md.unifyDatetime(data, rv)
+	}
+
+	// Special case. Look for a value satisfying the TextUnmarshaler interface.
+	if v, ok := rv.Interface().(TextUnmarshaler); ok {
+		return md.unifyText(data, v)
+	}
+	// BUG(burntsushi)
+	// The behavior here is incorrect whenever a Go type satisfies the
+	// encoding.TextUnmarshaler interface but also corresponds to a TOML
+	// hash or array. In particular, the unmarshaler should only be applied
+	// to primitive TOML values. But at this point, it will be applied to
+	// all kinds of values and produce an incorrect error whenever those values
+	// are hashes or arrays (including arrays of tables).
+
+	k := rv.Kind()
+
+	// laziness
+	if k >= reflect.Int && k <= reflect.Uint64 {
+		return md.unifyInt(data, rv)
+	}
+	switch k {
+	case reflect.Ptr:
+		elem := reflect.New(rv.Type().Elem())
+		err := md.unify(data, reflect.Indirect(elem))
+		if err != nil {
+			return err
+		}
+		rv.Set(elem)
+		return nil
+	case reflect.Struct:
+		return md.unifyStruct(data, rv)
+	case reflect.Map:
+		return md.unifyMap(data, rv)
+	case reflect.Array:
+		return md.unifyArray(data, rv)
+	case reflect.Slice:
+		return md.unifySlice(data, rv)
+	case reflect.String:
+		return md.unifyString(data, rv)
+	case reflect.Bool:
+		return md.unifyBool(data, rv)
+	case reflect.Interface:
+		// we only support empty interfaces.
+		if rv.NumMethod() > 0 {
+			return e("unsupported type %s", rv.Type())
+		}
+		return md.unifyAnything(data, rv)
+	case reflect.Float32:
+		fallthrough
+	case reflect.Float64:
+		return md.unifyFloat64(data, rv)
+	}
+	return e("unsupported type %s", rv.Kind())
+}
+
+func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {
+	tmap, ok := mapping.(map[string]interface{})
+	if !ok {
+		if mapping == nil {
+			return nil
+		}
+		return e("type mismatch for %s: expected table but found %T",
+			rv.Type().String(), mapping)
+	}
+
+	for key, datum := range tmap {
+		var f *field
+		fields := cachedTypeFields(rv.Type())
+		for i := range fields {
+			ff := &fields[i]
+			if ff.name == key {
+				f = ff
+				break
+			}
+			if f == nil && strings.EqualFold(ff.name, key) {
+				f = ff
+			}
+		}
+		if f != nil {
+			subv := rv
+			for _, i := range f.index {
+				subv = indirect(subv.Field(i))
+			}
+			if isUnifiable(subv) {
+				md.decoded[md.context.add(key).String()] = true
+				md.context = append(md.context, key)
+				if err := md.unify(datum, subv); err != nil {
+					return err
+				}
+				md.context = md.context[0 : len(md.context)-1]
+			} else if f.name != "" {
+				// Bad user! No soup for you!
+				return e("cannot write unexported field %s.%s",
+					rv.Type().String(), f.name)
+			}
+		}
+	}
+	return nil
+}
+
+func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {
+	tmap, ok := mapping.(map[string]interface{})
+	if !ok {
+		if tmap == nil {
+			return nil
+		}
+		return badtype("map", mapping)
+	}
+	if rv.IsNil() {
+		rv.Set(reflect.MakeMap(rv.Type()))
+	}
+	for k, v := range tmap {
+		md.decoded[md.context.add(k).String()] = true
+		md.context = append(md.context, k)
+
+		rvkey := indirect(reflect.New(rv.Type().Key()))
+		rvval := reflect.Indirect(reflect.New(rv.Type().Elem()))
+		if err := md.unify(v, rvval); err != nil {
+			return err
+		}
+		md.context = md.context[0 : len(md.context)-1]
+
+		rvkey.SetString(k)
+		rv.SetMapIndex(rvkey, rvval)
+	}
+	return nil
+}
+
+func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {
+	datav := reflect.ValueOf(data)
+	if datav.Kind() != reflect.Slice {
+		if !datav.IsValid() {
+			return nil
+		}
+		return badtype("slice", data)
+	}
+	sliceLen := datav.Len()
+	if sliceLen != rv.Len() {
+		return e("expected array length %d; got TOML array of length %d",
+			rv.Len(), sliceLen)
+	}
+	return md.unifySliceArray(datav, rv)
+}
+
+func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {
+	datav := reflect.ValueOf(data)
+	if datav.Kind() != reflect.Slice {
+		if !datav.IsValid() {
+			return nil
+		}
+		return badtype("slice", data)
+	}
+	n := datav.Len()
+	if rv.IsNil() || rv.Cap() < n {
+		rv.Set(reflect.MakeSlice(rv.Type(), n, n))
+	}
+	rv.SetLen(n)
+	return md.unifySliceArray(datav, rv)
+}
+
+func (md *MetaData) unifySliceArray(data, rv reflect.Value) error {
+	sliceLen := data.Len()
+	for i := 0; i < sliceLen; i++ {
+		v := data.Index(i).Interface()
+		sliceval := indirect(rv.Index(i))
+		if err := md.unify(v, sliceval); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) error {
+	if _, ok := data.(time.Time); ok {
+		rv.Set(reflect.ValueOf(data))
+		return nil
+	}
+	return badtype("time.Time", data)
+}
+
+func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error {
+	if s, ok := data.(string); ok {
+		rv.SetString(s)
+		return nil
+	}
+	return badtype("string", data)
+}
+
+func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error {
+	if num, ok := data.(float64); ok {
+		switch rv.Kind() {
+		case reflect.Float32:
+			fallthrough
+		case reflect.Float64:
+			rv.SetFloat(num)
+		default:
+			panic("bug")
+		}
+		return nil
+	}
+	return badtype("float", data)
+}
+
+func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {
+	if num, ok := data.(int64); ok {
+		if rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Int64 {
+			switch rv.Kind() {
+			case reflect.Int, reflect.Int64:
+				// No bounds checking necessary.
+			case reflect.Int8:
+				if num < math.MinInt8 || num > math.MaxInt8 {
+					return e("value %d is out of range for int8", num)
+				}
+			case reflect.Int16:
+				if num < math.MinInt16 || num > math.MaxInt16 {
+					return e("value %d is out of range for int16", num)
+				}
+			case reflect.Int32:
+				if num < math.MinInt32 || num > math.MaxInt32 {
+					return e("value %d is out of range for int32", num)
+				}
+			}
+			rv.SetInt(num)
+		} else if rv.Kind() >= reflect.Uint && rv.Kind() <= reflect.Uint64 {
+			unum := uint64(num)
+			switch rv.Kind() {
+			case reflect.Uint, reflect.Uint64:
+				// No bounds checking necessary.
+			case reflect.Uint8:
+				if num < 0 || unum > math.MaxUint8 {
+					return e("value %d is out of range for uint8", num)
+				}
+			case reflect.Uint16:
+				if num < 0 || unum > math.MaxUint16 {
+					return e("value %d is out of range for uint16", num)
+				}
+			case reflect.Uint32:
+				if num < 0 || unum > math.MaxUint32 {
+					return e("value %d is out of range for uint32", num)
+				}
+			}
+			rv.SetUint(unum)
+		} else {
+			panic("unreachable")
+		}
+		return nil
+	}
+	return badtype("integer", data)
+}
+
+func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error {
+	if b, ok := data.(bool); ok {
+		rv.SetBool(b)
+		return nil
+	}
+	return badtype("boolean", data)
+}
+
+func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error {
+	rv.Set(reflect.ValueOf(data))
+	return nil
+}
+
+func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error {
+	var s string
+	switch sdata := data.(type) {
+	case TextMarshaler:
+		text, err := sdata.MarshalText()
+		if err != nil {
+			return err
+		}
+		s = string(text)
+	case fmt.Stringer:
+		s = sdata.String()
+	case string:
+		s = sdata
+	case bool:
+		s = fmt.Sprintf("%v", sdata)
+	case int64:
+		s = fmt.Sprintf("%d", sdata)
+	case float64:
+		s = fmt.Sprintf("%f", sdata)
+	default:
+		return badtype("primitive (string-like)", data)
+	}
+	if err := v.UnmarshalText([]byte(s)); err != nil {
+		return err
+	}
+	return nil
+}
+
+// rvalue returns a reflect.Value of `v`. All pointers are resolved.
+func rvalue(v interface{}) reflect.Value {
+	return indirect(reflect.ValueOf(v))
+}
+
+// indirect returns the value pointed to by a pointer.
+// Pointers are followed until the value is not a pointer.
+// New values are allocated for each nil pointer.
+//
+// An exception to this rule is if the value satisfies an interface of
+// interest to us (like encoding.TextUnmarshaler).
+func indirect(v reflect.Value) reflect.Value {
+	if v.Kind() != reflect.Ptr {
+		if v.CanSet() {
+			pv := v.Addr()
+			if _, ok := pv.Interface().(TextUnmarshaler); ok {
+				return pv
+			}
+		}
+		return v
+	}
+	if v.IsNil() {
+		v.Set(reflect.New(v.Type().Elem()))
+	}
+	return indirect(reflect.Indirect(v))
+}
+
+func isUnifiable(rv reflect.Value) bool {
+	if rv.CanSet() {
+		return true
+	}
+	if _, ok := rv.Interface().(TextUnmarshaler); ok {
+		return true
+	}
+	return false
+}
+
+func badtype(expected string, data interface{}) error {
+	return e("cannot load TOML value of type %T into a Go %s", data, expected)
+}

vendor/github.com/BurntSushi/toml/decode_meta.go

@@ -0,0 +1,121 @@
+package toml
+
+import "strings"
+
+// MetaData allows access to meta information about TOML data that may not
+// be inferrable via reflection. In particular, whether a key has been defined
+// and the TOML type of a key.
+type MetaData struct {
+	mapping map[string]interface{}
+	types   map[string]tomlType
+	keys    []Key
+	decoded map[string]bool
+	context Key // Used only during decoding.
+}
+
+// IsDefined returns true if the key given exists in the TOML data. The key
+// should be specified hierarchially. e.g.,
+//
+//	// access the TOML key 'a.b.c'
+//	IsDefined("a", "b", "c")
+//
+// IsDefined will return false if an empty key given. Keys are case sensitive.
+func (md *MetaData) IsDefined(key ...string) bool {
+	if len(key) == 0 {
+		return false
+	}
+
+	var hash map[string]interface{}
+	var ok bool
+	var hashOrVal interface{} = md.mapping
+	for _, k := range key {
+		if hash, ok = hashOrVal.(map[string]interface{}); !ok {
+			return false
+		}
+		if hashOrVal, ok = hash[k]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// Type returns a string representation of the type of the key specified.
+//
+// Type will return the empty string if given an empty key or a key that
+// does not exist. Keys are case sensitive.
+func (md *MetaData) Type(key ...string) string {
+	fullkey := strings.Join(key, ".")
+	if typ, ok := md.types[fullkey]; ok {
+		return typ.typeString()
+	}
+	return ""
+}
+
+// Key is the type of any TOML key, including key groups. Use (MetaData).Keys
+// to get values of this type.
+type Key []string
+
+func (k Key) String() string {
+	return strings.Join(k, ".")
+}
+
+func (k Key) maybeQuotedAll() string {
+	var ss []string
+	for i := range k {
+		ss = append(ss, k.maybeQuoted(i))
+	}
+	return strings.Join(ss, ".")
+}
+
+func (k Key) maybeQuoted(i int) string {
+	quote := false
+	for _, c := range k[i] {
+		if !isBareKeyChar(c) {
+			quote = true
+			break
+		}
+	}
+	if quote {
+		return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\""
+	}
+	return k[i]
+}
+
+func (k Key) add(piece string) Key {
+	newKey := make(Key, len(k)+1)
+	copy(newKey, k)
+	newKey[len(k)] = piece
+	return newKey
+}
+
+// Keys returns a slice of every key in the TOML data, including key groups.
+// Each key is itself a slice, where the first element is the top of the
+// hierarchy and the last is the most specific.
+//
+// The list will have the same order as the keys appeared in the TOML data.
+//
+// All keys returned are non-empty.
+func (md *MetaData) Keys() []Key {
+	return md.keys
+}
+
+// Undecoded returns all keys that have not been decoded in the order in which
+// they appear in the original TOML document.
+//
+// This includes keys that haven't been decoded because of a Primitive value.
+// Once the Primitive value is decoded, the keys will be considered decoded.
+//
+// Also note that decoding into an empty interface will result in no decoding,
+// and so no keys will be considered decoded.
+//
+// In this sense, the Undecoded keys correspond to keys in the TOML document
+// that do not have a concrete type in your representation.
+func (md *MetaData) Undecoded() []Key {
+	undecoded := make([]Key, 0, len(md.keys))
+	for _, key := range md.keys {
+		if !md.decoded[key.String()] {
+			undecoded = append(undecoded, key)
+		}
+	}
+	return undecoded
+}

vendor/github.com/BurntSushi/toml/doc.go

@@ -0,0 +1,27 @@
+/*
+Package toml provides facilities for decoding and encoding TOML configuration
+files via reflection. There is also support for delaying decoding with
+the Primitive type, and querying the set of keys in a TOML document with the
+MetaData type.
+
+The specification implemented: https://github.com/mojombo/toml
+
+The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify
+whether a file is a valid TOML document. It can also be used to print the
+type of each key in a TOML document.
+
+Testing
+
+There are two important types of tests used for this package. The first is
+contained inside '*_test.go' files and uses the standard Go unit testing
+framework. These tests are primarily devoted to holistically testing the
+decoder and encoder.
+
+The second type of testing is used to verify the implementation's adherence
+to the TOML specification. These tests have been factored into their own
+project: https://github.com/BurntSushi/toml-test
+
+The reason the tests are in a separate project is so that they can be used by
+any implementation of TOML. Namely, it is language agnostic.
+*/
+package toml

vendor/github.com/BurntSushi/toml/encode.go

@@ -0,0 +1,568 @@
+package toml
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type tomlEncodeError struct{ error }
+
+var (
+	errArrayMixedElementTypes = errors.New(
+		"toml: cannot encode array with mixed element types")
+	errArrayNilElement = errors.New(
+		"toml: cannot encode array with nil element")
+	errNonString = errors.New(
+		"toml: cannot encode a map with non-string key type")
+	errAnonNonStruct = errors.New(
+		"toml: cannot encode an anonymous field that is not a struct")
+	errArrayNoTable = errors.New(
+		"toml: TOML array element cannot contain a table")
+	errNoKey = errors.New(
+		"toml: top-level values must be Go maps or structs")
+	errAnything = errors.New("") // used in testing
+)
+
+var quotedReplacer = strings.NewReplacer(
+	"\t", "\\t",
+	"\n", "\\n",
+	"\r", "\\r",
+	"\"", "\\\"",
+	"\\", "\\\\",
+)
+
+// Encoder controls the encoding of Go values to a TOML document to some
+// io.Writer.
+//
+// The indentation level can be controlled with the Indent field.
+type Encoder struct {
+	// A single indentation level. By default it is two spaces.
+	Indent string
+
+	// hasWritten is whether we have written any output to w yet.
+	hasWritten bool
+	w          *bufio.Writer
+}
+
+// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
+// given. By default, a single indentation level is 2 spaces.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{
+		w:      bufio.NewWriter(w),
+		Indent: "  ",
+	}
+}
+
+// Encode writes a TOML representation of the Go value to the underlying
+// io.Writer. If the value given cannot be encoded to a valid TOML document,
+// then an error is returned.
+//
+// The mapping between Go values and TOML values should be precisely the same
+// as for the Decode* functions. Similarly, the TextMarshaler interface is
+// supported by encoding the resulting bytes as strings. (If you want to write
+// arbitrary binary data then you will need to use something like base64 since
+// TOML does not have any binary types.)
+//
+// When encoding TOML hashes (i.e., Go maps or structs), keys without any
+// sub-hashes are encoded first.
+//
+// If a Go map is encoded, then its keys are sorted alphabetically for
+// deterministic output. More control over this behavior may be provided if
+// there is demand for it.
+//
+// Encoding Go values without a corresponding TOML representation---like map
+// types with non-string keys---will cause an error to be returned. Similarly
+// for mixed arrays/slices, arrays/slices with nil elements, embedded
+// non-struct types and nested slices containing maps or structs.
+// (e.g., [][]map[string]string is not allowed but []map[string]string is OK
+// and so is []map[string][]string.)
+func (enc *Encoder) Encode(v interface{}) error {
+	rv := eindirect(reflect.ValueOf(v))
+	if err := enc.safeEncode(Key([]string{}), rv); err != nil {
+		return err
+	}
+	return enc.w.Flush()
+}
+
+func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			if terr, ok := r.(tomlEncodeError); ok {
+				err = terr.error
+				return
+			}
+			panic(r)
+		}
+	}()
+	enc.encode(key, rv)
+	return nil
+}
+
+func (enc *Encoder) encode(key Key, rv reflect.Value) {
+	// Special case. Time needs to be in ISO8601 format.
+	// Special case. If we can marshal the type to text, then we used that.
+	// Basically, this prevents the encoder for handling these types as
+	// generic structs (or whatever the underlying type of a TextMarshaler is).
+	switch rv.Interface().(type) {
+	case time.Time, TextMarshaler:
+		enc.keyEqElement(key, rv)
+		return
+	}
+
+	k := rv.Kind()
+	switch k {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
+		reflect.Uint64,
+		reflect.Float32, reflect.Float64, reflect.String, reflect.Bool:
+		enc.keyEqElement(key, rv)
+	case reflect.Array, reflect.Slice:
+		if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) {
+			enc.eArrayOfTables(key, rv)
+		} else {
+			enc.keyEqElement(key, rv)
+		}
+	case reflect.Interface:
+		if rv.IsNil() {
+			return
+		}
+		enc.encode(key, rv.Elem())
+	case reflect.Map:
+		if rv.IsNil() {
+			return
+		}
+		enc.eTable(key, rv)
+	case reflect.Ptr:
+		if rv.IsNil() {
+			return
+		}
+		enc.encode(key, rv.Elem())
+	case reflect.Struct:
+		enc.eTable(key, rv)
+	default:
+		panic(e("unsupported type for key '%s': %s", key, k))
+	}
+}
+
+// eElement encodes any value that can be an array element (primitives and
+// arrays).
+func (enc *Encoder) eElement(rv reflect.Value) {
+	switch v := rv.Interface().(type) {
+	case time.Time:
+		// Special case time.Time as a primitive. Has to come before
+		// TextMarshaler below because time.Time implements
+		// encoding.TextMarshaler, but we need to always use UTC.
+		enc.wf(v.UTC().Format("2006-01-02T15:04:05Z"))
+		return
+	case TextMarshaler:
+		// Special case. Use text marshaler if it's available for this value.
+		if s, err := v.MarshalText(); err != nil {
+			encPanic(err)
+		} else {
+			enc.writeQuoted(string(s))
+		}
+		return
+	}
+	switch rv.Kind() {
+	case reflect.Bool:
+		enc.wf(strconv.FormatBool(rv.Bool()))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64:
+		enc.wf(strconv.FormatInt(rv.Int(), 10))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16,
+		reflect.Uint32, reflect.Uint64:
+		enc.wf(strconv.FormatUint(rv.Uint(), 10))
+	case reflect.Float32:
+		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32)))
+	case reflect.Float64:
+		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64)))
+	case reflect.Array, reflect.Slice:
+		enc.eArrayOrSliceElement(rv)
+	case reflect.Interface:
+		enc.eElement(rv.Elem())
+	case reflect.String:
+		enc.writeQuoted(rv.String())
+	default:
+		panic(e("unexpected primitive type: %s", rv.Kind()))
+	}
+}
+
+// By the TOML spec, all floats must have a decimal with at least one
+// number on either side.
+func floatAddDecimal(fstr string) string {
+	if !strings.Contains(fstr, ".") {
+		return fstr + ".0"
+	}
+	return fstr
+}
+
+func (enc *Encoder) writeQuoted(s string) {
+	enc.wf("\"%s\"", quotedReplacer.Replace(s))
+}
+
+func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) {
+	length := rv.Len()
+	enc.wf("[")
+	for i := 0; i < length; i++ {
+		elem := rv.Index(i)
+		enc.eElement(elem)
+		if i != length-1 {
+			enc.wf(", ")
+		}
+	}
+	enc.wf("]")
+}
+
+func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
+	if len(key) == 0 {
+		encPanic(errNoKey)
+	}
+	for i := 0; i < rv.Len(); i++ {
+		trv := rv.Index(i)
+		if isNil(trv) {
+			continue
+		}
+		panicIfInvalidKey(key)
+		enc.newline()
+		enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll())
+		enc.newline()
+		enc.eMapOrStruct(key, trv)
+	}
+}
+
+func (enc *Encoder) eTable(key Key, rv reflect.Value) {
+	panicIfInvalidKey(key)
+	if len(key) == 1 {
+		// Output an extra new line between top-level tables.
+		// (The newline isn't written if nothing else has been written though.)
+		enc.newline()
+	}
+	if len(key) > 0 {
+		enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll())
+		enc.newline()
+	}
+	enc.eMapOrStruct(key, rv)
+}
+
+func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) {
+	switch rv := eindirect(rv); rv.Kind() {
+	case reflect.Map:
+		enc.eMap(key, rv)
+	case reflect.Struct:
+		enc.eStruct(key, rv)
+	default:
+		panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String())
+	}
+}
+
+func (enc *Encoder) eMap(key Key, rv reflect.Value) {
+	rt := rv.Type()
+	if rt.Key().Kind() != reflect.String {
+		encPanic(errNonString)
+	}
+
+	// Sort keys so that we have deterministic output. And write keys directly
+	// underneath this key first, before writing sub-structs or sub-maps.
+	var mapKeysDirect, mapKeysSub []string
+	for _, mapKey := range rv.MapKeys() {
+		k := mapKey.String()
+		if typeIsHash(tomlTypeOfGo(rv.MapIndex(mapKey))) {
+			mapKeysSub = append(mapKeysSub, k)
+		} else {
+			mapKeysDirect = append(mapKeysDirect, k)
+		}
+	}
+
+	var writeMapKeys = func(mapKeys []string) {
+		sort.Strings(mapKeys)
+		for _, mapKey := range mapKeys {
+			mrv := rv.MapIndex(reflect.ValueOf(mapKey))
+			if isNil(mrv) {
+				// Don't write anything for nil fields.
+				continue
+			}
+			enc.encode(key.add(mapKey), mrv)
+		}
+	}
+	writeMapKeys(mapKeysDirect)
+	writeMapKeys(mapKeysSub)
+}
+
+func (enc *Encoder) eStruct(key Key, rv reflect.Value) {
+	// Write keys for fields directly under this key first, because if we write
+	// a field that creates a new table, then all keys under it will be in that
+	// table (not the one we're writing here).
+	rt := rv.Type()
+	var fieldsDirect, fieldsSub [][]int
+	var addFields func(rt reflect.Type, rv reflect.Value, start []int)
+	addFields = func(rt reflect.Type, rv reflect.Value, start []int) {
+		for i := 0; i < rt.NumField(); i++ {
+			f := rt.Field(i)
+			// skip unexported fields
+			if f.PkgPath != "" && !f.Anonymous {
+				continue
+			}
+			frv := rv.Field(i)
+			if f.Anonymous {
+				t := f.Type
+				switch t.Kind() {
+				case reflect.Struct:
+					// Treat anonymous struct fields with
+					// tag names as though they are not
+					// anonymous, like encoding/json does.
+					if getOptions(f.Tag).name == "" {
+						addFields(t, frv, f.Index)
+						continue
+					}
+				case reflect.Ptr:
+					if t.Elem().Kind() == reflect.Struct &&
+						getOptions(f.Tag).name == "" {
+						if !frv.IsNil() {
+							addFields(t.Elem(), frv.Elem(), f.Index)
+						}
+						continue
+					}
+					// Fall through to the normal field encoding logic below
+					// for non-struct anonymous fields.
+				}
+			}
+
+			if typeIsHash(tomlTypeOfGo(frv)) {
+				fieldsSub = append(fieldsSub, append(start, f.Index...))
+			} else {
+				fieldsDirect = append(fieldsDirect, append(start, f.Index...))
+			}
+		}
+	}
+	addFields(rt, rv, nil)
+
+	var writeFields = func(fields [][]int) {
+		for _, fieldIndex := range fields {
+			sft := rt.FieldByIndex(fieldIndex)
+			sf := rv.FieldByIndex(fieldIndex)
+			if isNil(sf) {
+				// Don't write anything for nil fields.
+				continue
+			}
+
+			opts := getOptions(sft.Tag)
+			if opts.skip {
+				continue
+			}
+			keyName := sft.Name
+			if opts.name != "" {
+				keyName = opts.name
+			}
+			if opts.omitempty && isEmpty(sf) {
+				continue
+			}
+			if opts.omitzero && isZero(sf) {
+				continue
+			}
+
+			enc.encode(key.add(keyName), sf)
+		}
+	}
+	writeFields(fieldsDirect)
+	writeFields(fieldsSub)
+}
+
+// tomlTypeName returns the TOML type name of the Go value's type. It is
+// used to determine whether the types of array elements are mixed (which is
+// forbidden). If the Go value is nil, then it is illegal for it to be an array
+// element, and valueIsNil is returned as true.
+
+// Returns the TOML type of a Go value. The type may be `nil`, which means
+// no concrete TOML type could be found.
+func tomlTypeOfGo(rv reflect.Value) tomlType {
+	if isNil(rv) || !rv.IsValid() {
+		return nil
+	}
+	switch rv.Kind() {
+	case reflect.Bool:
+		return tomlBool
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
+		reflect.Uint64:
+		return tomlInteger
+	case reflect.Float32, reflect.Float64:
+		return tomlFloat
+	case reflect.Array, reflect.Slice:
+		if typeEqual(tomlHash, tomlArrayType(rv)) {
+			return tomlArrayHash
+		}
+		return tomlArray
+	case reflect.Ptr, reflect.Interface:
+		return tomlTypeOfGo(rv.Elem())
+	case reflect.String:
+		return tomlString
+	case reflect.Map:
+		return tomlHash
+	case reflect.Struct:
+		switch rv.Interface().(type) {
+		case time.Time:
+			return tomlDatetime
+		case TextMarshaler:
+			return tomlString
+		default:
+			return tomlHash
+		}
+	default:
+		panic("unexpected reflect.Kind: " + rv.Kind().String())
+	}
+}
+
+// tomlArrayType returns the element type of a TOML array. The type returned
+// may be nil if it cannot be determined (e.g., a nil slice or a zero length
+// slize). This function may also panic if it finds a type that cannot be
+// expressed in TOML (such as nil elements, heterogeneous arrays or directly
+// nested arrays of tables).
+func tomlArrayType(rv reflect.Value) tomlType {
+	if isNil(rv) || !rv.IsValid() || rv.Len() == 0 {
+		return nil
+	}
+	firstType := tomlTypeOfGo(rv.Index(0))
+	if firstType == nil {
+		encPanic(errArrayNilElement)
+	}
+
+	rvlen := rv.Len()
+	for i := 1; i < rvlen; i++ {
+		elem := rv.Index(i)
+		switch elemType := tomlTypeOfGo(elem); {
+		case elemType == nil:
+			encPanic(errArrayNilElement)
+		case !typeEqual(firstType, elemType):
+			encPanic(errArrayMixedElementTypes)
+		}
+	}
+	// If we have a nested array, then we must make sure that the nested
+	// array contains ONLY primitives.
+	// This checks arbitrarily nested arrays.
+	if typeEqual(firstType, tomlArray) || typeEqual(firstType, tomlArrayHash) {
+		nest := tomlArrayType(eindirect(rv.Index(0)))
+		if typeEqual(nest, tomlHash) || typeEqual(nest, tomlArrayHash) {
+			encPanic(errArrayNoTable)
+		}
+	}
+	return firstType
+}
+
+type tagOptions struct {
+	skip      bool // "-"
+	name      string
+	omitempty bool
+	omitzero  bool
+}
+
+func getOptions(tag reflect.StructTag) tagOptions {
+	t := tag.Get("toml")
+	if t == "-" {
+		return tagOptions{skip: true}
+	}
+	var opts tagOptions
+	parts := strings.Split(t, ",")
+	opts.name = parts[0]
+	for _, s := range parts[1:] {
+		switch s {
+		case "omitempty":
+			opts.omitempty = true
+		case "omitzero":
+			opts.omitzero = true
+		}
+	}
+	return opts
+}
+
+func isZero(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return rv.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return rv.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return rv.Float() == 0.0
+	}
+	return false
+}
+
+func isEmpty(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
+		return rv.Len() == 0
+	case reflect.Bool:
+		return !rv.Bool()
+	}
+	return false
+}
+
+func (enc *Encoder) newline() {
+	if enc.hasWritten {
+		enc.wf("\n")
+	}
+}
+
+func (enc *Encoder) keyEqElement(key Key, val reflect.Value) {
+	if len(key) == 0 {
+		encPanic(errNoKey)
+	}
+	panicIfInvalidKey(key)
+	enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1))
+	enc.eElement(val)
+	enc.newline()
+}
+
+func (enc *Encoder) wf(format string, v ...interface{}) {
+	if _, err := fmt.Fprintf(enc.w, format, v...); err != nil {
+		encPanic(err)
+	}
+	enc.hasWritten = true
+}
+
+func (enc *Encoder) indentStr(key Key) string {
+	return strings.Repeat(enc.Indent, len(key)-1)
+}
+
+func encPanic(err error) {
+	panic(tomlEncodeError{err})
+}
+
+func eindirect(v reflect.Value) reflect.Value {
+	switch v.Kind() {
+	case reflect.Ptr, reflect.Interface:
+		return eindirect(v.Elem())
+	default:
+		return v
+	}
+}
+
+func isNil(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return rv.IsNil()
+	default:
+		return false
+	}
+}
+
+func panicIfInvalidKey(key Key) {
+	for _, k := range key {
+		if len(k) == 0 {
+			encPanic(e("Key '%s' is not a valid table name. Key names "+
+				"cannot be empty.", key.maybeQuotedAll()))
+		}
+	}
+}
+
+func isValidKeyName(s string) bool {
+	return len(s) != 0
+}

vendor/github.com/BurntSushi/toml/encoding_types.go

@@ -0,0 +1,19 @@
+// +build go1.2
+
+package toml
+
+// In order to support Go 1.1, we define our own TextMarshaler and
+// TextUnmarshaler types. For Go 1.2+, we just alias them with the
+// standard library interfaces.
+
+import (
+	"encoding"
+)
+
+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
+// so that Go 1.1 can be supported.
+type TextMarshaler encoding.TextMarshaler
+
+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
+// here so that Go 1.1 can be supported.
+type TextUnmarshaler encoding.TextUnmarshaler

vendor/github.com/BurntSushi/toml/encoding_types_1.1.go

@@ -0,0 +1,18 @@
+// +build !go1.2
+
+package toml
+
+// These interfaces were introduced in Go 1.2, so we add them manually when
+// compiling for Go 1.1.
+
+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
+// so that Go 1.1 can be supported.
+type TextMarshaler interface {
+	MarshalText() (text []byte, err error)
+}
+
+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
+// here so that Go 1.1 can be supported.
+type TextUnmarshaler interface {
+	UnmarshalText(text []byte) error
+}

vendor/github.com/BurntSushi/toml/lex.go

@@ -0,0 +1,858 @@
+package toml
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+type itemType int
+
+const (
+	itemError itemType = iota
+	itemNIL            // used in the parser to indicate no type
+	itemEOF
+	itemText
+	itemString
+	itemRawString
+	itemMultilineString
+	itemRawMultilineString
+	itemBool
+	itemInteger
+	itemFloat
+	itemDatetime
+	itemArray // the start of an array
+	itemArrayEnd
+	itemTableStart
+	itemTableEnd
+	itemArrayTableStart
+	itemArrayTableEnd
+	itemKeyStart
+	itemCommentStart
+)
+
+const (
+	eof             = 0
+	tableStart      = '['
+	tableEnd        = ']'
+	arrayTableStart = '['
+	arrayTableEnd   = ']'
+	tableSep        = '.'
+	keySep          = '='
+	arrayStart      = '['
+	arrayEnd        = ']'
+	arrayValTerm    = ','
+	commentStart    = '#'
+	stringStart     = '"'
+	stringEnd       = '"'
+	rawStringStart  = '\''
+	rawStringEnd    = '\''
+)
+
+type stateFn func(lx *lexer) stateFn
+
+type lexer struct {
+	input string
+	start int
+	pos   int
+	width int
+	line  int
+	state stateFn
+	items chan item
+
+	// A stack of state functions used to maintain context.
+	// The idea is to reuse parts of the state machine in various places.
+	// For example, values can appear at the top level or within arbitrarily
+	// nested arrays. The last state on the stack is used after a value has
+	// been lexed. Similarly for comments.
+	stack []stateFn
+}
+
+type item struct {
+	typ  itemType
+	val  string
+	line int
+}
+
+func (lx *lexer) nextItem() item {
+	for {
+		select {
+		case item := <-lx.items:
+			return item
+		default:
+			lx.state = lx.state(lx)
+		}
+	}
+}
+
+func lex(input string) *lexer {
+	lx := &lexer{
+		input: input + "\n",
+		state: lexTop,
+		line:  1,
+		items: make(chan item, 10),
+		stack: make([]stateFn, 0, 10),
+	}
+	return lx
+}
+
+func (lx *lexer) push(state stateFn) {
+	lx.stack = append(lx.stack, state)
+}
+
+func (lx *lexer) pop() stateFn {
+	if len(lx.stack) == 0 {
+		return lx.errorf("BUG in lexer: no states to pop.")
+	}
+	last := lx.stack[len(lx.stack)-1]
+	lx.stack = lx.stack[0 : len(lx.stack)-1]
+	return last
+}
+
+func (lx *lexer) current() string {
+	return lx.input[lx.start:lx.pos]
+}
+
+func (lx *lexer) emit(typ itemType) {
+	lx.items <- item{typ, lx.current(), lx.line}
+	lx.start = lx.pos
+}
+
+func (lx *lexer) emitTrim(typ itemType) {
+	lx.items <- item{typ, strings.TrimSpace(lx.current()), lx.line}
+	lx.start = lx.pos
+}
+
+func (lx *lexer) next() (r rune) {
+	if lx.pos >= len(lx.input) {
+		lx.width = 0
+		return eof
+	}
+
+	if lx.input[lx.pos] == '\n' {
+		lx.line++
+	}
+	r, lx.width = utf8.DecodeRuneInString(lx.input[lx.pos:])
+	lx.pos += lx.width
+	return r
+}
+
+// ignore skips over the pending input before this point.
+func (lx *lexer) ignore() {
+	lx.start = lx.pos
+}
+
+// backup steps back one rune. Can be called only once per call of next.
+func (lx *lexer) backup() {
+	lx.pos -= lx.width
+	if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' {
+		lx.line--
+	}
+}
+
+// accept consumes the next rune if it's equal to `valid`.
+func (lx *lexer) accept(valid rune) bool {
+	if lx.next() == valid {
+		return true
+	}
+	lx.backup()
+	return false
+}
+
+// peek returns but does not consume the next rune in the input.
+func (lx *lexer) peek() rune {
+	r := lx.next()
+	lx.backup()
+	return r
+}
+
+// skip ignores all input that matches the given predicate.
+func (lx *lexer) skip(pred func(rune) bool) {
+	for {
+		r := lx.next()
+		if pred(r) {
+			continue
+		}
+		lx.backup()
+		lx.ignore()
+		return
+	}
+}
+
+// errorf stops all lexing by emitting an error and returning `nil`.
+// Note that any value that is a character is escaped if it's a special
+// character (new lines, tabs, etc.).
+func (lx *lexer) errorf(format string, values ...interface{}) stateFn {
+	lx.items <- item{
+		itemError,
+		fmt.Sprintf(format, values...),
+		lx.line,
+	}
+	return nil
+}
+
+// lexTop consumes elements at the top level of TOML data.
+func lexTop(lx *lexer) stateFn {
+	r := lx.next()
+	if isWhitespace(r) || isNL(r) {
+		return lexSkip(lx, lexTop)
+	}
+
+	switch r {
+	case commentStart:
+		lx.push(lexTop)
+		return lexCommentStart
+	case tableStart:
+		return lexTableStart
+	case eof:
+		if lx.pos > lx.start {
+			return lx.errorf("Unexpected EOF.")
+		}
+		lx.emit(itemEOF)
+		return nil
+	}
+
+	// At this point, the only valid item can be a key, so we back up
+	// and let the key lexer do the rest.
+	lx.backup()
+	lx.push(lexTopEnd)
+	return lexKeyStart
+}
+
+// lexTopEnd is entered whenever a top-level item has been consumed. (A value
+// or a table.) It must see only whitespace, and will turn back to lexTop
+// upon a new line. If it sees EOF, it will quit the lexer successfully.
+func lexTopEnd(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == commentStart:
+		// a comment will read to a new line for us.
+		lx.push(lexTop)
+		return lexCommentStart
+	case isWhitespace(r):
+		return lexTopEnd
+	case isNL(r):
+		lx.ignore()
+		return lexTop
+	case r == eof:
+		lx.ignore()
+		return lexTop
+	}
+	return lx.errorf("Expected a top-level item to end with a new line, "+
+		"comment or EOF, but got %q instead.", r)
+}
+
+// lexTable lexes the beginning of a table. Namely, it makes sure that
+// it starts with a character other than '.' and ']'.
+// It assumes that '[' has already been consumed.
+// It also handles the case that this is an item in an array of tables.
+// e.g., '[[name]]'.
+func lexTableStart(lx *lexer) stateFn {
+	if lx.peek() == arrayTableStart {
+		lx.next()
+		lx.emit(itemArrayTableStart)
+		lx.push(lexArrayTableEnd)
+	} else {
+		lx.emit(itemTableStart)
+		lx.push(lexTableEnd)
+	}
+	return lexTableNameStart
+}
+
+func lexTableEnd(lx *lexer) stateFn {
+	lx.emit(itemTableEnd)
+	return lexTopEnd
+}
+
+func lexArrayTableEnd(lx *lexer) stateFn {
+	if r := lx.next(); r != arrayTableEnd {
+		return lx.errorf("Expected end of table array name delimiter %q, "+
+			"but got %q instead.", arrayTableEnd, r)
+	}
+	lx.emit(itemArrayTableEnd)
+	return lexTopEnd
+}
+
+func lexTableNameStart(lx *lexer) stateFn {
+	lx.skip(isWhitespace)
+	switch r := lx.peek(); {
+	case r == tableEnd || r == eof:
+		return lx.errorf("Unexpected end of table name. (Table names cannot " +
+			"be empty.)")
+	case r == tableSep:
+		return lx.errorf("Unexpected table separator. (Table names cannot " +
+			"be empty.)")
+	case r == stringStart || r == rawStringStart:
+		lx.ignore()
+		lx.push(lexTableNameEnd)
+		return lexValue // reuse string lexing
+	default:
+		return lexBareTableName
+	}
+}
+
+// lexBareTableName lexes the name of a table. It assumes that at least one
+// valid character for the table has already been read.
+func lexBareTableName(lx *lexer) stateFn {
+	r := lx.next()
+	if isBareKeyChar(r) {
+		return lexBareTableName
+	}
+	lx.backup()
+	lx.emit(itemText)
+	return lexTableNameEnd
+}
+
+// lexTableNameEnd reads the end of a piece of a table name, optionally
+// consuming whitespace.
+func lexTableNameEnd(lx *lexer) stateFn {
+	lx.skip(isWhitespace)
+	switch r := lx.next(); {
+	case isWhitespace(r):
+		return lexTableNameEnd
+	case r == tableSep:
+		lx.ignore()
+		return lexTableNameStart
+	case r == tableEnd:
+		return lx.pop()
+	default:
+		return lx.errorf("Expected '.' or ']' to end table name, but got %q "+
+			"instead.", r)
+	}
+}
+
+// lexKeyStart consumes a key name up until the first non-whitespace character.
+// lexKeyStart will ignore whitespace.
+func lexKeyStart(lx *lexer) stateFn {
+	r := lx.peek()
+	switch {
+	case r == keySep:
+		return lx.errorf("Unexpected key separator %q.", keySep)
+	case isWhitespace(r) || isNL(r):
+		lx.next()
+		return lexSkip(lx, lexKeyStart)
+	case r == stringStart || r == rawStringStart:
+		lx.ignore()
+		lx.emit(itemKeyStart)
+		lx.push(lexKeyEnd)
+		return lexValue // reuse string lexing
+	default:
+		lx.ignore()
+		lx.emit(itemKeyStart)
+		return lexBareKey
+	}
+}
+
+// lexBareKey consumes the text of a bare key. Assumes that the first character
+// (which is not whitespace) has not yet been consumed.
+func lexBareKey(lx *lexer) stateFn {
+	switch r := lx.next(); {
+	case isBareKeyChar(r):
+		return lexBareKey
+	case isWhitespace(r):
+		lx.backup()
+		lx.emit(itemText)
+		return lexKeyEnd
+	case r == keySep:
+		lx.backup()
+		lx.emit(itemText)
+		return lexKeyEnd
+	default:
+		return lx.errorf("Bare keys cannot contain %q.", r)
+	}
+}
+
+// lexKeyEnd consumes the end of a key and trims whitespace (up to the key
+// separator).
+func lexKeyEnd(lx *lexer) stateFn {
+	switch r := lx.next(); {
+	case r == keySep:
+		return lexSkip(lx, lexValue)
+	case isWhitespace(r):
+		return lexSkip(lx, lexKeyEnd)
+	default:
+		return lx.errorf("Expected key separator %q, but got %q instead.",
+			keySep, r)
+	}
+}
+
+// lexValue starts the consumption of a value anywhere a value is expected.
+// lexValue will ignore whitespace.
+// After a value is lexed, the last state on the next is popped and returned.
+func lexValue(lx *lexer) stateFn {
+	// We allow whitespace to precede a value, but NOT new lines.
+	// In array syntax, the array states are responsible for ignoring new
+	// lines.
+	r := lx.next()
+	switch {
+	case isWhitespace(r):
+		return lexSkip(lx, lexValue)
+	case isDigit(r):
+		lx.backup() // avoid an extra state and use the same as above
+		return lexNumberOrDateStart
+	}
+	switch r {
+	case arrayStart:
+		lx.ignore()
+		lx.emit(itemArray)
+		return lexArrayValue
+	case stringStart:
+		if lx.accept(stringStart) {
+			if lx.accept(stringStart) {
+				lx.ignore() // Ignore """
+				return lexMultilineString
+			}
+			lx.backup()
+		}
+		lx.ignore() // ignore the '"'
+		return lexString
+	case rawStringStart:
+		if lx.accept(rawStringStart) {
+			if lx.accept(rawStringStart) {
+				lx.ignore() // Ignore """
+				return lexMultilineRawString
+			}
+			lx.backup()
+		}
+		lx.ignore() // ignore the "'"
+		return lexRawString
+	case '+', '-':
+		return lexNumberStart
+	case '.': // special error case, be kind to users
+		return lx.errorf("Floats must start with a digit, not '.'.")
+	}
+	if unicode.IsLetter(r) {
+		// Be permissive here; lexBool will give a nice error if the
+		// user wrote something like
+		//   x = foo
+		// (i.e. not 'true' or 'false' but is something else word-like.)
+		lx.backup()
+		return lexBool
+	}
+	return lx.errorf("Expected value but found %q instead.", r)
+}
+
+// lexArrayValue consumes one value in an array. It assumes that '[' or ','
+// have already been consumed. All whitespace and new lines are ignored.
+func lexArrayValue(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r) || isNL(r):
+		return lexSkip(lx, lexArrayValue)
+	case r == commentStart:
+		lx.push(lexArrayValue)
+		return lexCommentStart
+	case r == arrayValTerm:
+		return lx.errorf("Unexpected array value terminator %q.",
+			arrayValTerm)
+	case r == arrayEnd:
+		return lexArrayEnd
+	}
+
+	lx.backup()
+	lx.push(lexArrayValueEnd)
+	return lexValue
+}
+
+// lexArrayValueEnd consumes the cruft between values of an array. Namely,
+// it ignores whitespace and expects either a ',' or a ']'.
+func lexArrayValueEnd(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r) || isNL(r):
+		return lexSkip(lx, lexArrayValueEnd)
+	case r == commentStart:
+		lx.push(lexArrayValueEnd)
+		return lexCommentStart
+	case r == arrayValTerm:
+		lx.ignore()
+		return lexArrayValue // move on to the next value
+	case r == arrayEnd:
+		return lexArrayEnd
+	}
+	return lx.errorf("Expected an array value terminator %q or an array "+
+		"terminator %q, but got %q instead.", arrayValTerm, arrayEnd, r)
+}
+
+// lexArrayEnd finishes the lexing of an array. It assumes that a ']' has
+// just been consumed.
+func lexArrayEnd(lx *lexer) stateFn {
+	lx.ignore()
+	lx.emit(itemArrayEnd)
+	return lx.pop()
+}
+
+// lexString consumes the inner contents of a string. It assumes that the
+// beginning '"' has already been consumed and ignored.
+func lexString(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isNL(r):
+		return lx.errorf("Strings cannot contain new lines.")
+	case r == '\\':
+		lx.push(lexString)
+		return lexStringEscape
+	case r == stringEnd:
+		lx.backup()
+		lx.emit(itemString)
+		lx.next()
+		lx.ignore()
+		return lx.pop()
+	}
+	return lexString
+}
+
+// lexMultilineString consumes the inner contents of a string. It assumes that
+// the beginning '"""' has already been consumed and ignored.
+func lexMultilineString(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == '\\':
+		return lexMultilineStringEscape
+	case r == stringEnd:
+		if lx.accept(stringEnd) {
+			if lx.accept(stringEnd) {
+				lx.backup()
+				lx.backup()
+				lx.backup()
+				lx.emit(itemMultilineString)
+				lx.next()
+				lx.next()
+				lx.next()
+				lx.ignore()
+				return lx.pop()
+			}
+			lx.backup()
+		}
+	}
+	return lexMultilineString
+}
+
+// lexRawString consumes a raw string. Nothing can be escaped in such a string.
+// It assumes that the beginning "'" has already been consumed and ignored.
+func lexRawString(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isNL(r):
+		return lx.errorf("Strings cannot contain new lines.")
+	case r == rawStringEnd:
+		lx.backup()
+		lx.emit(itemRawString)
+		lx.next()
+		lx.ignore()
+		return lx.pop()
+	}
+	return lexRawString
+}
+
+// lexMultilineRawString consumes a raw string. Nothing can be escaped in such
+// a string. It assumes that the beginning "'" has already been consumed and
+// ignored.
+func lexMultilineRawString(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == rawStringEnd:
+		if lx.accept(rawStringEnd) {
+			if lx.accept(rawStringEnd) {
+				lx.backup()
+				lx.backup()
+				lx.backup()
+				lx.emit(itemRawMultilineString)
+				lx.next()
+				lx.next()
+				lx.next()
+				lx.ignore()
+				return lx.pop()
+			}
+			lx.backup()
+		}
+	}
+	return lexMultilineRawString
+}
+
+// lexMultilineStringEscape consumes an escaped character. It assumes that the
+// preceding '\\' has already been consumed.
+func lexMultilineStringEscape(lx *lexer) stateFn {
+	// Handle the special case first:
+	if isNL(lx.next()) {
+		return lexMultilineString
+	}
+	lx.backup()
+	lx.push(lexMultilineString)
+	return lexStringEscape(lx)
+}
+
+func lexStringEscape(lx *lexer) stateFn {
+	r := lx.next()
+	switch r {
+	case 'b':
+		fallthrough
+	case 't':
+		fallthrough
+	case 'n':
+		fallthrough
+	case 'f':
+		fallthrough
+	case 'r':
+		fallthrough
+	case '"':
+		fallthrough
+	case '\\':
+		return lx.pop()
+	case 'u':
+		return lexShortUnicodeEscape
+	case 'U':
+		return lexLongUnicodeEscape
+	}
+	return lx.errorf("Invalid escape character %q. Only the following "+
+		"escape characters are allowed: "+
+		"\\b, \\t, \\n, \\f, \\r, \\\", \\/, \\\\, "+
+		"\\uXXXX and \\UXXXXXXXX.", r)
+}
+
+func lexShortUnicodeEscape(lx *lexer) stateFn {
+	var r rune
+	for i := 0; i < 4; i++ {
+		r = lx.next()
+		if !isHexadecimal(r) {
+			return lx.errorf("Expected four hexadecimal digits after '\\u', "+
+				"but got '%s' instead.", lx.current())
+		}
+	}
+	return lx.pop()
+}
+
+func lexLongUnicodeEscape(lx *lexer) stateFn {
+	var r rune
+	for i := 0; i < 8; i++ {
+		r = lx.next()
+		if !isHexadecimal(r) {
+			return lx.errorf("Expected eight hexadecimal digits after '\\U', "+
+				"but got '%s' instead.", lx.current())
+		}
+	}
+	return lx.pop()
+}
+
+// lexNumberOrDateStart consumes either an integer, a float, or datetime.
+func lexNumberOrDateStart(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumberOrDate
+	}
+	switch r {
+	case '_':
+		return lexNumber
+	case 'e', 'E':
+		return lexFloat
+	case '.':
+		return lx.errorf("Floats must start with a digit, not '.'.")
+	}
+	return lx.errorf("Expected a digit but got %q.", r)
+}
+
+// lexNumberOrDate consumes either an integer, float or datetime.
+func lexNumberOrDate(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumberOrDate
+	}
+	switch r {
+	case '-':
+		return lexDatetime
+	case '_':
+		return lexNumber
+	case '.', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemInteger)
+	return lx.pop()
+}
+
+// lexDatetime consumes a Datetime, to a first approximation.
+// The parser validates that it matches one of the accepted formats.
+func lexDatetime(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexDatetime
+	}
+	switch r {
+	case '-', 'T', ':', '.', 'Z':
+		return lexDatetime
+	}
+
+	lx.backup()
+	lx.emit(itemDatetime)
+	return lx.pop()
+}
+
+// lexNumberStart consumes either an integer or a float. It assumes that a sign
+// has already been read, but that *no* digits have been consumed.
+// lexNumberStart will move to the appropriate integer or float states.
+func lexNumberStart(lx *lexer) stateFn {
+	// We MUST see a digit. Even floats have to start with a digit.
+	r := lx.next()
+	if !isDigit(r) {
+		if r == '.' {
+			return lx.errorf("Floats must start with a digit, not '.'.")
+		}
+		return lx.errorf("Expected a digit but got %q.", r)
+	}
+	return lexNumber
+}
+
+// lexNumber consumes an integer or a float after seeing the first digit.
+func lexNumber(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumber
+	}
+	switch r {
+	case '_':
+		return lexNumber
+	case '.', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemInteger)
+	return lx.pop()
+}
+
+// lexFloat consumes the elements of a float. It allows any sequence of
+// float-like characters, so floats emitted by the lexer are only a first
+// approximation and must be validated by the parser.
+func lexFloat(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexFloat
+	}
+	switch r {
+	case '_', '.', '-', '+', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemFloat)
+	return lx.pop()
+}
+
+// lexBool consumes a bool string: 'true' or 'false.
+func lexBool(lx *lexer) stateFn {
+	var rs []rune
+	for {
+		r := lx.next()
+		if r == eof || isWhitespace(r) || isNL(r) {
+			lx.backup()
+			break
+		}
+		rs = append(rs, r)
+	}
+	s := string(rs)
+	switch s {
+	case "true", "false":
+		lx.emit(itemBool)
+		return lx.pop()
+	}
+	return lx.errorf("Expected value but found %q instead.", s)
+}
+
+// lexCommentStart begins the lexing of a comment. It will emit
+// itemCommentStart and consume no characters, passing control to lexComment.
+func lexCommentStart(lx *lexer) stateFn {
+	lx.ignore()
+	lx.emit(itemCommentStart)
+	return lexComment
+}
+
+// lexComment lexes an entire comment. It assumes that '#' has been consumed.
+// It will consume *up to* the first new line character, and pass control
+// back to the last state on the stack.
+func lexComment(lx *lexer) stateFn {
+	r := lx.peek()
+	if isNL(r) || r == eof {
+		lx.emit(itemText)
+		return lx.pop()
+	}
+	lx.next()
+	return lexComment
+}
+
+// lexSkip ignores all slurped input and moves on to the next state.
+func lexSkip(lx *lexer, nextState stateFn) stateFn {
+	return func(lx *lexer) stateFn {
+		lx.ignore()
+		return nextState
+	}
+}
+
+// isWhitespace returns true if `r` is a whitespace character according
+// to the spec.
+func isWhitespace(r rune) bool {
+	return r == '\t' || r == ' '
+}
+
+func isNL(r rune) bool {
+	return r == '\n' || r == '\r'
+}
+
+func isDigit(r rune) bool {
+	return r >= '0' && r <= '9'
+}
+
+func isHexadecimal(r rune) bool {
+	return (r >= '0' && r <= '9') ||
+		(r >= 'a' && r <= 'f') ||
+		(r >= 'A' && r <= 'F')
+}
+
+func isBareKeyChar(r rune) bool {
+	return (r >= 'A' && r <= 'Z') ||
+		(r >= 'a' && r <= 'z') ||
+		(r >= '0' && r <= '9') ||
+		r == '_' ||
+		r == '-'
+}
+
+func (itype itemType) String() string {
+	switch itype {
+	case itemError:
+		return "Error"
+	case itemNIL:
+		return "NIL"
+	case itemEOF:
+		return "EOF"
+	case itemText:
+		return "Text"
+	case itemString, itemRawString, itemMultilineString, itemRawMultilineString:
+		return "String"
+	case itemBool:
+		return "Bool"
+	case itemInteger:
+		return "Integer"
+	case itemFloat:
+		return "Float"
+	case itemDatetime:
+		return "DateTime"
+	case itemTableStart:
+		return "TableStart"
+	case itemTableEnd:
+		return "TableEnd"
+	case itemKeyStart:
+		return "KeyStart"
+	case itemArray:
+		return "Array"
+	case itemArrayEnd:
+		return "ArrayEnd"
+	case itemCommentStart:
+		return "CommentStart"
+	}
+	panic(fmt.Sprintf("BUG: Unknown type '%d'.", int(itype)))
+}
+
+func (item item) String() string {
+	return fmt.Sprintf("(%s, %s)", item.typ.String(), item.val)
+}

vendor/github.com/BurntSushi/toml/parse.go

@@ -0,0 +1,557 @@
+package toml
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+type parser struct {
+	mapping map[string]interface{}
+	types   map[string]tomlType
+	lx      *lexer
+
+	// A list of keys in the order that they appear in the TOML data.
+	ordered []Key
+
+	// the full key for the current hash in scope
+	context Key
+
+	// the base key name for everything except hashes
+	currentKey string
+
+	// rough approximation of line number
+	approxLine int
+
+	// A map of 'key.group.names' to whether they were created implicitly.
+	implicits map[string]bool
+}
+
+type parseError string
+
+func (pe parseError) Error() string {
+	return string(pe)
+}
+
+func parse(data string) (p *parser, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			if err, ok = r.(parseError); ok {
+				return
+			}
+			panic(r)
+		}
+	}()
+
+	p = &parser{
+		mapping:   make(map[string]interface{}),
+		types:     make(map[string]tomlType),
+		lx:        lex(data),
+		ordered:   make([]Key, 0),
+		implicits: make(map[string]bool),
+	}
+	for {
+		item := p.next()
+		if item.typ == itemEOF {
+			break
+		}
+		p.topLevel(item)
+	}
+
+	return p, nil
+}
+
+func (p *parser) panicf(format string, v ...interface{}) {
+	msg := fmt.Sprintf("Near line %d (last key parsed '%s'): %s",
+		p.approxLine, p.current(), fmt.Sprintf(format, v...))
+	panic(parseError(msg))
+}
+
+func (p *parser) next() item {
+	it := p.lx.nextItem()
+	if it.typ == itemError {
+		p.panicf("%s", it.val)
+	}
+	return it
+}
+
+func (p *parser) bug(format string, v ...interface{}) {
+	panic(fmt.Sprintf("BUG: "+format+"\n\n", v...))
+}
+
+func (p *parser) expect(typ itemType) item {
+	it := p.next()
+	p.assertEqual(typ, it.typ)
+	return it
+}
+
+func (p *parser) assertEqual(expected, got itemType) {
+	if expected != got {
+		p.bug("Expected '%s' but got '%s'.", expected, got)
+	}
+}
+
+func (p *parser) topLevel(item item) {
+	switch item.typ {
+	case itemCommentStart:
+		p.approxLine = item.line
+		p.expect(itemText)
+	case itemTableStart:
+		kg := p.next()
+		p.approxLine = kg.line
+
+		var key Key
+		for ; kg.typ != itemTableEnd && kg.typ != itemEOF; kg = p.next() {
+			key = append(key, p.keyString(kg))
+		}
+		p.assertEqual(itemTableEnd, kg.typ)
+
+		p.establishContext(key, false)
+		p.setType("", tomlHash)
+		p.ordered = append(p.ordered, key)
+	case itemArrayTableStart:
+		kg := p.next()
+		p.approxLine = kg.line
+
+		var key Key
+		for ; kg.typ != itemArrayTableEnd && kg.typ != itemEOF; kg = p.next() {
+			key = append(key, p.keyString(kg))
+		}
+		p.assertEqual(itemArrayTableEnd, kg.typ)
+
+		p.establishContext(key, true)
+		p.setType("", tomlArrayHash)
+		p.ordered = append(p.ordered, key)
+	case itemKeyStart:
+		kname := p.next()
+		p.approxLine = kname.line
+		p.currentKey = p.keyString(kname)
+
+		val, typ := p.value(p.next())
+		p.setValue(p.currentKey, val)
+		p.setType(p.currentKey, typ)
+		p.ordered = append(p.ordered, p.context.add(p.currentKey))
+		p.currentKey = ""
+	default:
+		p.bug("Unexpected type at top level: %s", item.typ)
+	}
+}
+
+// Gets a string for a key (or part of a key in a table name).
+func (p *parser) keyString(it item) string {
+	switch it.typ {
+	case itemText:
+		return it.val
+	case itemString, itemMultilineString,
+		itemRawString, itemRawMultilineString:
+		s, _ := p.value(it)
+		return s.(string)
+	default:
+		p.bug("Unexpected key type: %s", it.typ)
+		panic("unreachable")
+	}
+}
+
+// value translates an expected value from the lexer into a Go value wrapped
+// as an empty interface.
+func (p *parser) value(it item) (interface{}, tomlType) {
+	switch it.typ {
+	case itemString:
+		return p.replaceEscapes(it.val), p.typeOfPrimitive(it)
+	case itemMultilineString:
+		trimmed := stripFirstNewline(stripEscapedWhitespace(it.val))
+		return p.replaceEscapes(trimmed), p.typeOfPrimitive(it)
+	case itemRawString:
+		return it.val, p.typeOfPrimitive(it)
+	case itemRawMultilineString:
+		return stripFirstNewline(it.val), p.typeOfPrimitive(it)
+	case itemBool:
+		switch it.val {
+		case "true":
+			return true, p.typeOfPrimitive(it)
+		case "false":
+			return false, p.typeOfPrimitive(it)
+		}
+		p.bug("Expected boolean value, but got '%s'.", it.val)
+	case itemInteger:
+		if !numUnderscoresOK(it.val) {
+			p.panicf("Invalid integer %q: underscores must be surrounded by digits",
+				it.val)
+		}
+		val := strings.Replace(it.val, "_", "", -1)
+		num, err := strconv.ParseInt(val, 10, 64)
+		if err != nil {
+			// Distinguish integer values. Normally, it'd be a bug if the lexer
+			// provides an invalid integer, but it's possible that the number is
+			// out of range of valid values (which the lexer cannot determine).
+			// So mark the former as a bug but the latter as a legitimate user
+			// error.
+			if e, ok := err.(*strconv.NumError); ok &&
+				e.Err == strconv.ErrRange {
+
+				p.panicf("Integer '%s' is out of the range of 64-bit "+
+					"signed integers.", it.val)
+			} else {
+				p.bug("Expected integer value, but got '%s'.", it.val)
+			}
+		}
+		return num, p.typeOfPrimitive(it)
+	case itemFloat:
+		parts := strings.FieldsFunc(it.val, func(r rune) bool {
+			switch r {
+			case '.', 'e', 'E':
+				return true
+			}
+			return false
+		})
+		for _, part := range parts {
+			if !numUnderscoresOK(part) {
+				p.panicf("Invalid float %q: underscores must be "+
+					"surrounded by digits", it.val)
+			}
+		}
+		if !numPeriodsOK(it.val) {
+			// As a special case, numbers like '123.' or '1.e2',
+			// which are valid as far as Go/strconv are concerned,
+			// must be rejected because TOML says that a fractional
+			// part consists of '.' followed by 1+ digits.
+			p.panicf("Invalid float %q: '.' must be followed "+
+				"by one or more digits", it.val)
+		}
+		val := strings.Replace(it.val, "_", "", -1)
+		num, err := strconv.ParseFloat(val, 64)
+		if err != nil {
+			if e, ok := err.(*strconv.NumError); ok &&
+				e.Err == strconv.ErrRange {
+
+				p.panicf("Float '%s' is out of the range of 64-bit "+
+					"IEEE-754 floating-point numbers.", it.val)
+			} else {
+				p.panicf("Invalid float value: %q", it.val)
+			}
+		}
+		return num, p.typeOfPrimitive(it)
+	case itemDatetime:
+		var t time.Time
+		var ok bool
+		var err error
+		for _, format := range []string{
+			"2006-01-02T15:04:05Z07:00",
+			"2006-01-02T15:04:05",
+			"2006-01-02",
+		} {
+			t, err = time.ParseInLocation(format, it.val, time.Local)
+			if err == nil {
+				ok = true
+				break
+			}
+		}
+		if !ok {
+			p.panicf("Invalid TOML Datetime: %q.", it.val)
+		}
+		return t, p.typeOfPrimitive(it)
+	case itemArray:
+		array := make([]interface{}, 0)
+		types := make([]tomlType, 0)
+
+		for it = p.next(); it.typ != itemArrayEnd; it = p.next() {
+			if it.typ == itemCommentStart {
+				p.expect(itemText)
+				continue
+			}
+
+			val, typ := p.value(it)
+			array = append(array, val)
+			types = append(types, typ)
+		}
+		return array, p.typeOfArray(types)
+	}
+	p.bug("Unexpected value type: %s", it.typ)
+	panic("unreachable")
+}
+
+// numUnderscoresOK checks whether each underscore in s is surrounded by
+// characters that are not underscores.
+func numUnderscoresOK(s string) bool {
+	accept := false
+	for _, r := range s {
+		if r == '_' {
+			if !accept {
+				return false
+			}
+			accept = false
+			continue
+		}
+		accept = true
+	}
+	return accept
+}
+
+// numPeriodsOK checks whether every period in s is followed by a digit.
+func numPeriodsOK(s string) bool {
+	period := false
+	for _, r := range s {
+		if period && !isDigit(r) {
+			return false
+		}
+		period = r == '.'
+	}
+	return !period
+}
+
+// establishContext sets the current context of the parser,
+// where the context is either a hash or an array of hashes. Which one is
+// set depends on the value of the `array` parameter.
+//
+// Establishing the context also makes sure that the key isn't a duplicate, and
+// will create implicit hashes automatically.
+func (p *parser) establishContext(key Key, array bool) {
+	var ok bool
+
+	// Always start at the top level and drill down for our context.
+	hashContext := p.mapping
+	keyContext := make(Key, 0)
+
+	// We only need implicit hashes for key[0:-1]
+	for _, k := range key[0 : len(key)-1] {
+		_, ok = hashContext[k]
+		keyContext = append(keyContext, k)
+
+		// No key? Make an implicit hash and move on.
+		if !ok {
+			p.addImplicit(keyContext)
+			hashContext[k] = make(map[string]interface{})
+		}
+
+		// If the hash context is actually an array of tables, then set
+		// the hash context to the last element in that array.
+		//
+		// Otherwise, it better be a table, since this MUST be a key group (by
+		// virtue of it not being the last element in a key).
+		switch t := hashContext[k].(type) {
+		case []map[string]interface{}:
+			hashContext = t[len(t)-1]
+		case map[string]interface{}:
+			hashContext = t
+		default:
+			p.panicf("Key '%s' was already created as a hash.", keyContext)
+		}
+	}
+
+	p.context = keyContext
+	if array {
+		// If this is the first element for this array, then allocate a new
+		// list of tables for it.
+		k := key[len(key)-1]
+		if _, ok := hashContext[k]; !ok {
+			hashContext[k] = make([]map[string]interface{}, 0, 5)
+		}
+
+		// Add a new table. But make sure the key hasn't already been used
+		// for something else.
+		if hash, ok := hashContext[k].([]map[string]interface{}); ok {
+			hashContext[k] = append(hash, make(map[string]interface{}))
+		} else {
+			p.panicf("Key '%s' was already created and cannot be used as "+
+				"an array.", keyContext)
+		}
+	} else {
+		p.setValue(key[len(key)-1], make(map[string]interface{}))
+	}
+	p.context = append(p.context, key[len(key)-1])
+}
+
+// setValue sets the given key to the given value in the current context.
+// It will make sure that the key hasn't already been defined, account for
+// implicit key groups.
+func (p *parser) setValue(key string, value interface{}) {
+	var tmpHash interface{}
+	var ok bool
+
+	hash := p.mapping
+	keyContext := make(Key, 0)
+	for _, k := range p.context {
+		keyContext = append(keyContext, k)
+		if tmpHash, ok = hash[k]; !ok {
+			p.bug("Context for key '%s' has not been established.", keyContext)
+		}
+		switch t := tmpHash.(type) {
+		case []map[string]interface{}:
+			// The context is a table of hashes. Pick the most recent table
+			// defined as the current hash.
+			hash = t[len(t)-1]
+		case map[string]interface{}:
+			hash = t
+		default:
+			p.bug("Expected hash to have type 'map[string]interface{}', but "+
+				"it has '%T' instead.", tmpHash)
+		}
+	}
+	keyContext = append(keyContext, key)
+
+	if _, ok := hash[key]; ok {
+		// Typically, if the given key has already been set, then we have
+		// to raise an error since duplicate keys are disallowed. However,
+		// it's possible that a key was previously defined implicitly. In this
+		// case, it is allowed to be redefined concretely. (See the
+		// `tests/valid/implicit-and-explicit-after.toml` test in `toml-test`.)
+		//
+		// But we have to make sure to stop marking it as an implicit. (So that
+		// another redefinition provokes an error.)
+		//
+		// Note that since it has already been defined (as a hash), we don't
+		// want to overwrite it. So our business is done.
+		if p.isImplicit(keyContext) {
+			p.removeImplicit(keyContext)
+			return
+		}
+
+		// Otherwise, we have a concrete key trying to override a previous
+		// key, which is *always* wrong.
+		p.panicf("Key '%s' has already been defined.", keyContext)
+	}
+	hash[key] = value
+}
+
+// setType sets the type of a particular value at a given key.
+// It should be called immediately AFTER setValue.
+//
+// Note that if `key` is empty, then the type given will be applied to the
+// current context (which is either a table or an array of tables).
+func (p *parser) setType(key string, typ tomlType) {
+	keyContext := make(Key, 0, len(p.context)+1)
+	for _, k := range p.context {
+		keyContext = append(keyContext, k)
+	}
+	if len(key) > 0 { // allow type setting for hashes
+		keyContext = append(keyContext, key)
+	}
+	p.types[keyContext.String()] = typ
+}
+
+// addImplicit sets the given Key as having been created implicitly.
+func (p *parser) addImplicit(key Key) {
+	p.implicits[key.String()] = true
+}
+
+// removeImplicit stops tagging the given key as having been implicitly
+// created.
+func (p *parser) removeImplicit(key Key) {
+	p.implicits[key.String()] = false
+}
+
+// isImplicit returns true if the key group pointed to by the key was created
+// implicitly.
+func (p *parser) isImplicit(key Key) bool {
+	return p.implicits[key.String()]
+}
+
+// current returns the full key name of the current context.
+func (p *parser) current() string {
+	if len(p.currentKey) == 0 {
+		return p.context.String()
+	}
+	if len(p.context) == 0 {
+		return p.currentKey
+	}
+	return fmt.Sprintf("%s.%s", p.context, p.currentKey)
+}
+
+func stripFirstNewline(s string) string {
+	if len(s) == 0 || s[0] != '\n' {
+		return s
+	}
+	return s[1:]
+}
+
+func stripEscapedWhitespace(s string) string {
+	esc := strings.Split(s, "\\\n")
+	if len(esc) > 1 {
+		for i := 1; i < len(esc); i++ {
+			esc[i] = strings.TrimLeftFunc(esc[i], unicode.IsSpace)
+		}
+	}
+	return strings.Join(esc, "")
+}
+
+func (p *parser) replaceEscapes(str string) string {
+	var replaced []rune
+	s := []byte(str)
+	r := 0
+	for r < len(s) {
+		if s[r] != '\\' {
+			c, size := utf8.DecodeRune(s[r:])
+			r += size
+			replaced = append(replaced, c)
+			continue
+		}
+		r += 1
+		if r >= len(s) {
+			p.bug("Escape sequence at end of string.")
+			return ""
+		}
+		switch s[r] {
+		default:
+			p.bug("Expected valid escape code after \\, but got %q.", s[r])
+			return ""
+		case 'b':
+			replaced = append(replaced, rune(0x0008))
+			r += 1
+		case 't':
+			replaced = append(replaced, rune(0x0009))
+			r += 1
+		case 'n':
+			replaced = append(replaced, rune(0x000A))
+			r += 1
+		case 'f':
+			replaced = append(replaced, rune(0x000C))
+			r += 1
+		case 'r':
+			replaced = append(replaced, rune(0x000D))
+			r += 1
+		case '"':
+			replaced = append(replaced, rune(0x0022))
+			r += 1
+		case '\\':
+			replaced = append(replaced, rune(0x005C))
+			r += 1
+		case 'u':
+			// At this point, we know we have a Unicode escape of the form
+			// `uXXXX` at [r, r+5). (Because the lexer guarantees this
+			// for us.)
+			escaped := p.asciiEscapeToUnicode(s[r+1 : r+5])
+			replaced = append(replaced, escaped)
+			r += 5
+		case 'U':
+			// At this point, we know we have a Unicode escape of the form
+			// `uXXXX` at [r, r+9). (Because the lexer guarantees this
+			// for us.)
+			escaped := p.asciiEscapeToUnicode(s[r+1 : r+9])
+			replaced = append(replaced, escaped)
+			r += 9
+		}
+	}
+	return string(replaced)
+}
+
+func (p *parser) asciiEscapeToUnicode(bs []byte) rune {
+	s := string(bs)
+	hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32)
+	if err != nil {
+		p.bug("Could not parse '%s' as a hexadecimal number, but the "+
+			"lexer claims it's OK: %s", s, err)
+	}
+	if !utf8.ValidRune(rune(hex)) {
+		p.panicf("Escaped character '\\u%s' is not valid UTF-8.", s)
+	}
+	return rune(hex)
+}
+
+func isStringType(ty itemType) bool {
+	return ty == itemString || ty == itemMultilineString ||
+		ty == itemRawString || ty == itemRawMultilineString
+}

vendor/github.com/BurntSushi/toml/type_check.go

@@ -0,0 +1,91 @@
+package toml
+
+// tomlType represents any Go type that corresponds to a TOML type.
+// While the first draft of the TOML spec has a simplistic type system that
+// probably doesn't need this level of sophistication, we seem to be militating
+// toward adding real composite types.
+type tomlType interface {
+	typeString() string
+}
+
+// typeEqual accepts any two types and returns true if they are equal.
+func typeEqual(t1, t2 tomlType) bool {
+	if t1 == nil || t2 == nil {
+		return false
+	}
+	return t1.typeString() == t2.typeString()
+}
+
+func typeIsHash(t tomlType) bool {
+	return typeEqual(t, tomlHash) || typeEqual(t, tomlArrayHash)
+}
+
+type tomlBaseType string
+
+func (btype tomlBaseType) typeString() string {
+	return string(btype)
+}
+
+func (btype tomlBaseType) String() string {
+	return btype.typeString()
+}
+
+var (
+	tomlInteger   tomlBaseType = "Integer"
+	tomlFloat     tomlBaseType = "Float"
+	tomlDatetime  tomlBaseType = "Datetime"
+	tomlString    tomlBaseType = "String"
+	tomlBool      tomlBaseType = "Bool"
+	tomlArray     tomlBaseType = "Array"
+	tomlHash      tomlBaseType = "Hash"
+	tomlArrayHash tomlBaseType = "ArrayHash"
+)
+
+// typeOfPrimitive returns a tomlType of any primitive value in TOML.
+// Primitive values are: Integer, Float, Datetime, String and Bool.
+//
+// Passing a lexer item other than the following will cause a BUG message
+// to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime.
+func (p *parser) typeOfPrimitive(lexItem item) tomlType {
+	switch lexItem.typ {
+	case itemInteger:
+		return tomlInteger
+	case itemFloat:
+		return tomlFloat
+	case itemDatetime:
+		return tomlDatetime
+	case itemString:
+		return tomlString
+	case itemMultilineString:
+		return tomlString
+	case itemRawString:
+		return tomlString
+	case itemRawMultilineString:
+		return tomlString
+	case itemBool:
+		return tomlBool
+	}
+	p.bug("Cannot infer primitive type of lex item '%s'.", lexItem)
+	panic("unreachable")
+}
+
+// typeOfArray returns a tomlType for an array given a list of types of its
+// values.
+//
+// In the current spec, if an array is homogeneous, then its type is always
+// "Array". If the array is not homogeneous, an error is generated.
+func (p *parser) typeOfArray(types []tomlType) tomlType {
+	// Empty arrays are cool.
+	if len(types) == 0 {
+		return tomlArray
+	}
+
+	theType := types[0]
+	for _, t := range types[1:] {
+		if !typeEqual(theType, t) {
+			p.panicf("Array contains values of type '%s' and '%s', but "+
+				"arrays must be homogeneous.", theType, t)
+		}
+	}
+	return tomlArray
+}

vendor/github.com/BurntSushi/toml/type_fields.go

@@ -0,0 +1,242 @@
+package toml
+
+// Struct field handling is adapted from code in encoding/json:
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the Go distribution.
+
+import (
+	"reflect"
+	"sort"
+	"sync"
+)
+
+// A field represents a single field found in a struct.
+type field struct {
+	name  string       // the name of the field (`toml` tag included)
+	tag   bool         // whether field has a `toml` tag
+	index []int        // represents the depth of an anonymous field
+	typ   reflect.Type // the type of the field
+}
+
+// byName sorts field by name, breaking ties with depth,
+// then breaking ties with "name came from toml tag", then
+// breaking ties with index sequence.
+type byName []field
+
+func (x byName) Len() int { return len(x) }
+
+func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+func (x byName) Less(i, j int) bool {
+	if x[i].name != x[j].name {
+		return x[i].name < x[j].name
+	}
+	if len(x[i].index) != len(x[j].index) {
+		return len(x[i].index) < len(x[j].index)
+	}
+	if x[i].tag != x[j].tag {
+		return x[i].tag
+	}
+	return byIndex(x).Less(i, j)
+}
+
+// byIndex sorts field by index sequence.
+type byIndex []field
+
+func (x byIndex) Len() int { return len(x) }
+
+func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+func (x byIndex) Less(i, j int) bool {
+	for k, xik := range x[i].index {
+		if k >= len(x[j].index) {
+			return false
+		}
+		if xik != x[j].index[k] {
+			return xik < x[j].index[k]
+		}
+	}
+	return len(x[i].index) < len(x[j].index)
+}
+
+// typeFields returns a list of fields that TOML should recognize for the given
+// type. The algorithm is breadth-first search over the set of structs to
+// include - the top struct and then any reachable anonymous structs.
+func typeFields(t reflect.Type) []field {
+	// Anonymous fields to explore at the current level and the next.
+	current := []field{}
+	next := []field{{typ: t}}
+
+	// Count of queued names for current level and the next.
+	count := map[reflect.Type]int{}
+	nextCount := map[reflect.Type]int{}
+
+	// Types already visited at an earlier level.
+	visited := map[reflect.Type]bool{}
+
+	// Fields found.
+	var fields []field
+
+	for len(next) > 0 {
+		current, next = next, current[:0]
+		count, nextCount = nextCount, map[reflect.Type]int{}
+
+		for _, f := range current {
+			if visited[f.typ] {
+				continue
+			}
+			visited[f.typ] = true
+
+			// Scan f.typ for fields to include.
+			for i := 0; i < f.typ.NumField(); i++ {
+				sf := f.typ.Field(i)
+				if sf.PkgPath != "" && !sf.Anonymous { // unexported
+					continue
+				}
+				opts := getOptions(sf.Tag)
+				if opts.skip {
+					continue
+				}
+				index := make([]int, len(f.index)+1)
+				copy(index, f.index)
+				index[len(f.index)] = i
+
+				ft := sf.Type
+				if ft.Name() == "" && ft.Kind() == reflect.Ptr {
+					// Follow pointer.
+					ft = ft.Elem()
+				}
+
+				// Record found field and index sequence.
+				if opts.name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
+					tagged := opts.name != ""
+					name := opts.name
+					if name == "" {
+						name = sf.Name
+					}
+					fields = append(fields, field{name, tagged, index, ft})
+					if count[f.typ] > 1 {
+						// If there were multiple instances, add a second,
+						// so that the annihilation code will see a duplicate.
+						// It only cares about the distinction between 1 or 2,
+						// so don't bother generating any more copies.
+						fields = append(fields, fields[len(fields)-1])
+					}
+					continue
+				}
+
+				// Record new anonymous struct to explore in next round.
+				nextCount[ft]++
+				if nextCount[ft] == 1 {
+					f := field{name: ft.Name(), index: index, typ: ft}
+					next = append(next, f)
+				}
+			}
+		}
+	}
+
+	sort.Sort(byName(fields))
+
+	// Delete all fields that are hidden by the Go rules for embedded fields,
+	// except that fields with TOML tags are promoted.
+
+	// The fields are sorted in primary order of name, secondary order
+	// of field index length. Loop over names; for each name, delete
+	// hidden fields by choosing the one dominant field that survives.
+	out := fields[:0]
+	for advance, i := 0, 0; i < len(fields); i += advance {
+		// One iteration per name.
+		// Find the sequence of fields with the name of this first field.
+		fi := fields[i]
+		name := fi.name
+		for advance = 1; i+advance < len(fields); advance++ {
+			fj := fields[i+advance]
+			if fj.name != name {
+				break
+			}
+		}
+		if advance == 1 { // Only one field with this name
+			out = append(out, fi)
+			continue
+		}
+		dominant, ok := dominantField(fields[i : i+advance])
+		if ok {
+			out = append(out, dominant)
+		}
+	}
+
+	fields = out
+	sort.Sort(byIndex(fields))
+
+	return fields
+}
+
+// dominantField looks through the fields, all of which are known to
+// have the same name, to find the single field that dominates the
+// others using Go's embedding rules, modified by the presence of
+// TOML tags. If there are multiple top-level fields, the boolean
+// will be false: This condition is an error in Go and we skip all
+// the fields.
+func dominantField(fields []field) (field, bool) {
+	// The fields are sorted in increasing index-length order. The winner
+	// must therefore be one with the shortest index length. Drop all
+	// longer entries, which is easy: just truncate the slice.
+	length := len(fields[0].index)
+	tagged := -1 // Index of first tagged field.
+	for i, f := range fields {
+		if len(f.index) > length {
+			fields = fields[:i]
+			break
+		}
+		if f.tag {
+			if tagged >= 0 {
+				// Multiple tagged fields at the same level: conflict.
+				// Return no field.
+				return field{}, false
+			}
+			tagged = i
+		}
+	}
+	if tagged >= 0 {
+		return fields[tagged], true
+	}
+	// All remaining fields have the same length. If there's more than one,
+	// we have a conflict (two fields named "X" at the same level) and we
+	// return no field.
+	if len(fields) > 1 {
+		return field{}, false
+	}
+	return fields[0], true
+}
+
+var fieldCache struct {
+	sync.RWMutex
+	m map[reflect.Type][]field
+}
+
+// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
+func cachedTypeFields(t reflect.Type) []field {
+	fieldCache.RLock()
+	f := fieldCache.m[t]
+	fieldCache.RUnlock()
+	if f != nil {
+		return f
+	}
+
+	// Compute fields without lock.
+	// Might duplicate effort but won't hold other computations back.
+	f = typeFields(t)
+	if f == nil {
+		f = []field{}
+	}
+
+	fieldCache.Lock()
+	if fieldCache.m == nil {
+		fieldCache.m = map[reflect.Type][]field{}
+	}
+	fieldCache.m[t] = f
+	fieldCache.Unlock()
+	return f
+}

vendor/github.com/bwmarrin/discordgo/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2015, Bruce Marriner
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of discordgo nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

vendor/github.com/bwmarrin/discordgo/discord.go

@@ -0,0 +1,257 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains high level helper functions and easy entry points for the
+// entire discordgo package.  These functions are beling developed and are very
+// experimental at this point.  They will most likley change so please use the
+// low level functions if that's a problem.
+
+// Package discordgo provides Discord binding for Go
+package discordgo
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// VERSION of Discordgo, follows Symantic Versioning. (http://semver.org/)
+const VERSION = "0.13.0"
+
+// New creates a new Discord session and will automate some startup
+// tasks if given enough information to do so.  Currently you can pass zero
+// arguments and it will return an empty Discord session.
+// There are 3 ways to call New:
+//     With a single auth token - All requests will use the token blindly,
+//         no verification of the token will be done and requests may fail.
+//     With an email and password - Discord will sign in with the provided
+//         credentials.
+//     With an email, password and auth token - Discord will verify the auth
+//         token, if it is invalid it will sign in with the provided
+//         credentials. This is the Discord recommended way to sign in.
+func New(args ...interface{}) (s *Session, err error) {
+
+	// Create an empty Session interface.
+	s = &Session{
+		State:                  NewState(),
+		StateEnabled:           true,
+		Compress:               true,
+		ShouldReconnectOnError: true,
+		ShardID:                0,
+		ShardCount:             1,
+	}
+
+	// If no arguments are passed return the empty Session interface.
+	if args == nil {
+		return
+	}
+
+	// Variables used below when parsing func arguments
+	var auth, pass string
+
+	// Parse passed arguments
+	for _, arg := range args {
+
+		switch v := arg.(type) {
+
+		case []string:
+			if len(v) > 3 {
+				err = fmt.Errorf("Too many string parameters provided.")
+				return
+			}
+
+			// First string is either token or username
+			if len(v) > 0 {
+				auth = v[0]
+			}
+
+			// If second string exists, it must be a password.
+			if len(v) > 1 {
+				pass = v[1]
+			}
+
+			// If third string exists, it must be an auth token.
+			if len(v) > 2 {
+				s.Token = v[2]
+			}
+
+		case string:
+			// First string must be either auth token or username.
+			// Second string must be a password.
+			// Only 2 input strings are supported.
+
+			if auth == "" {
+				auth = v
+			} else if pass == "" {
+				pass = v
+			} else if s.Token == "" {
+				s.Token = v
+			} else {
+				err = fmt.Errorf("Too many string parameters provided.")
+				return
+			}
+
+			//		case Config:
+			// TODO: Parse configuration struct
+
+		default:
+			err = fmt.Errorf("Unsupported parameter type provided.")
+			return
+		}
+	}
+
+	// If only one string was provided, assume it is an auth token.
+	// Otherwise get auth token from Discord, if a token was specified
+	// Discord will verify it for free, or log the user in if it is
+	// invalid.
+	if pass == "" {
+		s.Token = auth
+	} else {
+		err = s.Login(auth, pass)
+		if err != nil || s.Token == "" {
+			err = fmt.Errorf("Unable to fetch discord authentication token. %v", err)
+			return
+		}
+	}
+
+	// The Session is now able to have RestAPI methods called on it.
+	// It is recommended that you now call Open() so that events will trigger.
+
+	return
+}
+
+// validateHandler takes an event handler func, and returns the type of event.
+// eg.
+//     Session.validateHandler(func (s *discordgo.Session, m *discordgo.MessageCreate))
+//     will return the reflect.Type of *discordgo.MessageCreate
+func (s *Session) validateHandler(handler interface{}) reflect.Type {
+
+	handlerType := reflect.TypeOf(handler)
+
+	if handlerType.NumIn() != 2 {
+		panic("Unable to add event handler, handler must be of the type func(*discordgo.Session, *discordgo.EventType).")
+	}
+
+	if handlerType.In(0) != reflect.TypeOf(s) {
+		panic("Unable to add event handler, first argument must be of type *discordgo.Session.")
+	}
+
+	eventType := handlerType.In(1)
+
+	// Support handlers of type interface{}, this is a special handler, which is triggered on every event.
+	if eventType.Kind() == reflect.Interface {
+		eventType = nil
+	}
+
+	return eventType
+}
+
+// AddHandler allows you to add an event handler that will be fired anytime
+// the Discord WSAPI event that matches the interface fires.
+// eventToInterface in events.go has a list of all the Discord WSAPI events
+// and their respective interface.
+// eg:
+//     Session.AddHandler(func(s *discordgo.Session, m *discordgo.MessageCreate) {
+//     })
+//
+// or:
+//     Session.AddHandler(func(s *discordgo.Session, m *discordgo.PresenceUpdate) {
+//     })
+// The return value of this method is a function, that when called will remove the
+// event handler.
+func (s *Session) AddHandler(handler interface{}) func() {
+
+	s.initialize()
+
+	eventType := s.validateHandler(handler)
+
+	s.handlersMu.Lock()
+	defer s.handlersMu.Unlock()
+
+	h := reflect.ValueOf(handler)
+
+	s.handlers[eventType] = append(s.handlers[eventType], h)
+
+	// This must be done as we need a consistent reference to the
+	// reflected value, otherwise a RemoveHandler method would have
+	// been nice.
+	return func() {
+		s.handlersMu.Lock()
+		defer s.handlersMu.Unlock()
+
+		handlers := s.handlers[eventType]
+		for i, v := range handlers {
+			if h == v {
+				s.handlers[eventType] = append(handlers[:i], handlers[i+1:]...)
+				return
+			}
+		}
+	}
+}
+
+// handle calls any handlers that match the event type and any handlers of
+// interface{}.
+func (s *Session) handle(event interface{}) {
+
+	s.handlersMu.RLock()
+	defer s.handlersMu.RUnlock()
+
+	if s.handlers == nil {
+		return
+	}
+
+	handlerParameters := []reflect.Value{reflect.ValueOf(s), reflect.ValueOf(event)}
+
+	if handlers, ok := s.handlers[nil]; ok {
+		for _, handler := range handlers {
+			go handler.Call(handlerParameters)
+		}
+	}
+
+	if handlers, ok := s.handlers[reflect.TypeOf(event)]; ok {
+		for _, handler := range handlers {
+			go handler.Call(handlerParameters)
+		}
+	}
+}
+
+// initialize adds all internal handlers and state tracking handlers.
+func (s *Session) initialize() {
+
+	s.log(LogInformational, "called")
+
+	s.handlersMu.Lock()
+	if s.handlers != nil {
+		s.handlersMu.Unlock()
+		return
+	}
+
+	s.handlers = map[interface{}][]reflect.Value{}
+	s.handlersMu.Unlock()
+
+	s.AddHandler(s.onReady)
+	s.AddHandler(s.onResumed)
+	s.AddHandler(s.onVoiceServerUpdate)
+	s.AddHandler(s.onVoiceStateUpdate)
+	s.AddHandler(s.State.onInterface)
+}
+
+// onReady handles the ready event.
+func (s *Session) onReady(se *Session, r *Ready) {
+
+	// Store the SessionID within the Session struct.
+	s.sessionID = r.SessionID
+
+	// Start the heartbeat to keep the connection alive.
+	go s.heartbeat(s.wsConn, s.listening, r.HeartbeatInterval)
+}
+
+// onResumed handles the resumed event.
+func (s *Session) onResumed(se *Session, r *Resumed) {
+
+	// Start the heartbeat to keep the connection alive.
+	go s.heartbeat(s.wsConn, s.listening, r.HeartbeatInterval)
+}

vendor/github.com/bwmarrin/discordgo/endpoints.go

@@ -0,0 +1,99 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains variables for all known Discord end points.  All functions
+// throughout the Discordgo package use these variables for all connections
+// to Discord.  These are all exported and you may modify them if needed.
+
+package discordgo
+
+// Known Discord API Endpoints.
+var (
+	EndpointStatus     = "https://status.discordapp.com/api/v2/"
+	EndpointSm         = EndpointStatus + "scheduled-maintenances/"
+	EndpointSmActive   = EndpointSm + "active.json"
+	EndpointSmUpcoming = EndpointSm + "upcoming.json"
+
+	EndpointDiscord  = "https://discordapp.com/"
+	EndpointAPI      = EndpointDiscord + "api/"
+	EndpointGuilds   = EndpointAPI + "guilds/"
+	EndpointChannels = EndpointAPI + "channels/"
+	EndpointUsers    = EndpointAPI + "users/"
+	EndpointGateway  = EndpointAPI + "gateway"
+
+	EndpointAuth           = EndpointAPI + "auth/"
+	EndpointLogin          = EndpointAuth + "login"
+	EndpointLogout         = EndpointAuth + "logout"
+	EndpointVerify         = EndpointAuth + "verify"
+	EndpointVerifyResend   = EndpointAuth + "verify/resend"
+	EndpointForgotPassword = EndpointAuth + "forgot"
+	EndpointResetPassword  = EndpointAuth + "reset"
+	EndpointRegister       = EndpointAuth + "register"
+
+	EndpointVoice        = EndpointAPI + "/voice/"
+	EndpointVoiceRegions = EndpointVoice + "regions"
+	EndpointVoiceIce     = EndpointVoice + "ice"
+
+	EndpointTutorial           = EndpointAPI + "tutorial/"
+	EndpointTutorialIndicators = EndpointTutorial + "indicators"
+
+	EndpointTrack        = EndpointAPI + "track"
+	EndpointSso          = EndpointAPI + "sso"
+	EndpointReport       = EndpointAPI + "report"
+	EndpointIntegrations = EndpointAPI + "integrations"
+
+	EndpointUser              = func(uID string) string { return EndpointUsers + uID }
+	EndpointUserAvatar        = func(uID, aID string) string { return EndpointUsers + uID + "/avatars/" + aID + ".jpg" }
+	EndpointUserSettings      = func(uID string) string { return EndpointUsers + uID + "/settings" }
+	EndpointUserGuilds        = func(uID string) string { return EndpointUsers + uID + "/guilds" }
+	EndpointUserGuild         = func(uID, gID string) string { return EndpointUsers + uID + "/guilds/" + gID }
+	EndpointUserGuildSettings = func(uID, gID string) string { return EndpointUsers + uID + "/guilds/" + gID + "/settings" }
+	EndpointUserChannels      = func(uID string) string { return EndpointUsers + uID + "/channels" }
+	EndpointUserDevices       = func(uID string) string { return EndpointUsers + uID + "/devices" }
+	EndpointUserConnections   = func(uID string) string { return EndpointUsers + uID + "/connections" }
+
+	EndpointGuild                = func(gID string) string { return EndpointGuilds + gID }
+	EndpointGuildInivtes         = func(gID string) string { return EndpointGuilds + gID + "/invites" }
+	EndpointGuildChannels        = func(gID string) string { return EndpointGuilds + gID + "/channels" }
+	EndpointGuildMembers         = func(gID string) string { return EndpointGuilds + gID + "/members" }
+	EndpointGuildMember          = func(gID, uID string) string { return EndpointGuilds + gID + "/members/" + uID }
+	EndpointGuildBans            = func(gID string) string { return EndpointGuilds + gID + "/bans" }
+	EndpointGuildBan             = func(gID, uID string) string { return EndpointGuilds + gID + "/bans/" + uID }
+	EndpointGuildIntegrations    = func(gID string) string { return EndpointGuilds + gID + "/integrations" }
+	EndpointGuildIntegration     = func(gID, iID string) string { return EndpointGuilds + gID + "/integrations/" + iID }
+	EndpointGuildIntegrationSync = func(gID, iID string) string { return EndpointGuilds + gID + "/integrations/" + iID + "/sync" }
+	EndpointGuildRoles           = func(gID string) string { return EndpointGuilds + gID + "/roles" }
+	EndpointGuildRole            = func(gID, rID string) string { return EndpointGuilds + gID + "/roles/" + rID }
+	EndpointGuildInvites         = func(gID string) string { return EndpointGuilds + gID + "/invites" }
+	EndpointGuildEmbed           = func(gID string) string { return EndpointGuilds + gID + "/embed" }
+	EndpointGuildPrune           = func(gID string) string { return EndpointGuilds + gID + "/prune" }
+	EndpointGuildIcon            = func(gID, hash string) string { return EndpointGuilds + gID + "/icons/" + hash + ".jpg" }
+	EndpointGuildSplash          = func(gID, hash string) string { return EndpointGuilds + gID + "/splashes/" + hash + ".jpg" }
+
+	EndpointChannel                   = func(cID string) string { return EndpointChannels + cID }
+	EndpointChannelPermissions        = func(cID string) string { return EndpointChannels + cID + "/permissions" }
+	EndpointChannelPermission         = func(cID, tID string) string { return EndpointChannels + cID + "/permissions/" + tID }
+	EndpointChannelInvites            = func(cID string) string { return EndpointChannels + cID + "/invites" }
+	EndpointChannelTyping             = func(cID string) string { return EndpointChannels + cID + "/typing" }
+	EndpointChannelMessages           = func(cID string) string { return EndpointChannels + cID + "/messages" }
+	EndpointChannelMessage            = func(cID, mID string) string { return EndpointChannels + cID + "/messages/" + mID }
+	EndpointChannelMessageAck         = func(cID, mID string) string { return EndpointChannels + cID + "/messages/" + mID + "/ack" }
+	EndpointChannelMessagesBulkDelete = func(cID string) string { return EndpointChannel(cID) + "/messages/bulk_delete" }
+	EndpointChannelMessagesPins       = func(cID string) string { return EndpointChannel(cID) + "/pins" }
+	EndpointChannelMessagePin         = func(cID, mID string) string { return EndpointChannel(cID) + "/pins/" + mID }
+
+	EndpointInvite = func(iID string) string { return EndpointAPI + "invite/" + iID }
+
+	EndpointIntegrationsJoin = func(iID string) string { return EndpointAPI + "integrations/" + iID + "/join" }
+
+	EndpointEmoji = func(eID string) string { return EndpointAPI + "emojis/" + eID + ".png" }
+
+	EndpointOauth2          = EndpointAPI + "oauth2/"
+	EndpointApplications    = EndpointOauth2 + "applications"
+	EndpointApplication     = func(aID string) string { return EndpointApplications + "/" + aID }
+	EndpointApplicationsBot = func(aID string) string { return EndpointApplications + "/" + aID + "/bot" }
+)

vendor/github.com/bwmarrin/discordgo/events.go

@@ -0,0 +1,159 @@
+package discordgo
+
+// eventToInterface is a mapping of Discord WSAPI events to their
+// DiscordGo event container.
+// Each Discord WSAPI event maps to a unique interface.
+// Use Session.AddHandler with one of these types to handle that
+// type of event.
+// eg:
+//     Session.AddHandler(func(s *discordgo.Session, m *discordgo.MessageCreate) {
+//     })
+//
+// or:
+//     Session.AddHandler(func(s *discordgo.Session, m *discordgo.PresenceUpdate) {
+//     })
+var eventToInterface = map[string]interface{}{
+	"CHANNEL_CREATE":             ChannelCreate{},
+	"CHANNEL_UPDATE":             ChannelUpdate{},
+	"CHANNEL_DELETE":             ChannelDelete{},
+	"GUILD_CREATE":               GuildCreate{},
+	"GUILD_UPDATE":               GuildUpdate{},
+	"GUILD_DELETE":               GuildDelete{},
+	"GUILD_BAN_ADD":              GuildBanAdd{},
+	"GUILD_BAN_REMOVE":           GuildBanRemove{},
+	"GUILD_MEMBER_ADD":           GuildMemberAdd{},
+	"GUILD_MEMBER_UPDATE":        GuildMemberUpdate{},
+	"GUILD_MEMBER_REMOVE":        GuildMemberRemove{},
+	"GUILD_ROLE_CREATE":          GuildRoleCreate{},
+	"GUILD_ROLE_UPDATE":          GuildRoleUpdate{},
+	"GUILD_ROLE_DELETE":          GuildRoleDelete{},
+	"GUILD_INTEGRATIONS_UPDATE":  GuildIntegrationsUpdate{},
+	"GUILD_EMOJIS_UPDATE":        GuildEmojisUpdate{},
+	"MESSAGE_ACK":                MessageAck{},
+	"MESSAGE_CREATE":             MessageCreate{},
+	"MESSAGE_UPDATE":             MessageUpdate{},
+	"MESSAGE_DELETE":             MessageDelete{},
+	"PRESENCE_UPDATE":            PresenceUpdate{},
+	"PRESENCES_REPLACE":          PresencesReplace{},
+	"READY":                      Ready{},
+	"USER_UPDATE":                UserUpdate{},
+	"USER_SETTINGS_UPDATE":       UserSettingsUpdate{},
+	"USER_GUILD_SETTINGS_UPDATE": UserGuildSettingsUpdate{},
+	"TYPING_START":               TypingStart{},
+	"VOICE_SERVER_UPDATE":        VoiceServerUpdate{},
+	"VOICE_STATE_UPDATE":         VoiceStateUpdate{},
+	"RESUMED":                    Resumed{},
+}
+
+// Connect is an empty struct for an event.
+type Connect struct{}
+
+// Disconnect is an empty struct for an event.
+type Disconnect struct{}
+
+// RateLimit is a struct for the RateLimited event
+type RateLimit struct {
+	*TooManyRequests
+	URL string
+}
+
+// MessageCreate is a wrapper struct for an event.
+type MessageCreate struct {
+	*Message
+}
+
+// MessageUpdate is a wrapper struct for an event.
+type MessageUpdate struct {
+	*Message
+}
+
+// MessageDelete is a wrapper struct for an event.
+type MessageDelete struct {
+	*Message
+}
+
+// ChannelCreate is a wrapper struct for an event.
+type ChannelCreate struct {
+	*Channel
+}
+
+// ChannelUpdate is a wrapper struct for an event.
+type ChannelUpdate struct {
+	*Channel
+}
+
+// ChannelDelete is a wrapper struct for an event.
+type ChannelDelete struct {
+	*Channel
+}
+
+// GuildCreate is a wrapper struct for an event.
+type GuildCreate struct {
+	*Guild
+}
+
+// GuildUpdate is a wrapper struct for an event.
+type GuildUpdate struct {
+	*Guild
+}
+
+// GuildDelete is a wrapper struct for an event.
+type GuildDelete struct {
+	*Guild
+}
+
+// GuildBanAdd is a wrapper struct for an event.
+type GuildBanAdd struct {
+	*GuildBan
+}
+
+// GuildBanRemove is a wrapper struct for an event.
+type GuildBanRemove struct {
+	*GuildBan
+}
+
+// GuildMemberAdd is a wrapper struct for an event.
+type GuildMemberAdd struct {
+	*Member
+}
+
+// GuildMemberUpdate is a wrapper struct for an event.
+type GuildMemberUpdate struct {
+	*Member
+}
+
+// GuildMemberRemove is a wrapper struct for an event.
+type GuildMemberRemove struct {
+	*Member
+}
+
+// GuildRoleCreate is a wrapper struct for an event.
+type GuildRoleCreate struct {
+	*GuildRole
+}
+
+// GuildRoleUpdate is a wrapper struct for an event.
+type GuildRoleUpdate struct {
+	*GuildRole
+}
+
+// PresencesReplace is an array of Presences for an event.
+type PresencesReplace []*Presence
+
+// VoiceStateUpdate is a wrapper struct for an event.
+type VoiceStateUpdate struct {
+	*VoiceState
+}
+
+// UserUpdate is a wrapper struct for an event.
+type UserUpdate struct {
+	*User
+}
+
+// UserSettingsUpdate is a map for an event.
+type UserSettingsUpdate map[string]interface{}
+
+// UserGuildSettingsUpdate is a map for an event.
+type UserGuildSettingsUpdate struct {
+	*UserGuildSettings
+}

vendor/github.com/bwmarrin/discordgo/examples/airhorn/main.go

@@ -0,0 +1,186 @@
+package main
+
+import (
+	"encoding/binary"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+func init() {
+	flag.StringVar(&token, "t", "", "Account Token")
+	flag.Parse()
+}
+
+var token string
+var buffer = make([][]byte, 0)
+
+func main() {
+	if token == "" {
+		fmt.Println("No token provided. Please run: airhorn -t <bot token>")
+		return
+	}
+
+	// Load the sound file.
+	err := loadSound()
+	if err != nil {
+		fmt.Println("Error loading sound: ", err)
+		fmt.Println("Please copy $GOPATH/src/github.com/bwmarrin/examples/airhorn/airhorn.dca to this directory.")
+		return
+	}
+
+	// Create a new Discord session using the provided token.
+	dg, err := discordgo.New(token)
+	if err != nil {
+		fmt.Println("Error creating Discord session: ", err)
+		return
+	}
+
+	// Register ready as a callback for the ready events.
+	dg.AddHandler(ready)
+
+	// Register messageCreate as a callback for the messageCreate events.
+	dg.AddHandler(messageCreate)
+
+	// Register guildCreate as a callback for the guildCreate events.
+	dg.AddHandler(guildCreate)
+
+	// Open the websocket and begin listening.
+	err = dg.Open()
+	if err != nil {
+		fmt.Println("Error opening Discord session: ", err)
+	}
+
+	fmt.Println("Airhorn is now running.  Press CTRL-C to exit.")
+	// Simple way to keep program running until CTRL-C is pressed.
+	<-make(chan struct{})
+	return
+}
+
+func ready(s *discordgo.Session, event *discordgo.Ready) {
+	// Set the playing status.
+	_ = s.UpdateStatus(0, "!airhorn")
+}
+
+// This function will be called (due to AddHandler above) every time a new
+// message is created on any channel that the autenticated bot has access to.
+func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+	if strings.HasPrefix(m.Content, "!airhorn") {
+		// Find the channel that the message came from.
+		c, err := s.State.Channel(m.ChannelID)
+		if err != nil {
+			// Could not find channel.
+			return
+		}
+
+		// Find the guild for that channel.
+		g, err := s.State.Guild(c.GuildID)
+		if err != nil {
+			// Could not find guild.
+			return
+		}
+
+		// Look for the message sender in that guilds current voice states.
+		for _, vs := range g.VoiceStates {
+			if vs.UserID == m.Author.ID {
+				err = playSound(s, g.ID, vs.ChannelID)
+				if err != nil {
+					fmt.Println("Error playing sound:", err)
+				}
+
+				return
+			}
+		}
+	}
+}
+
+// This function will be called (due to AddHandler above) every time a new
+// guild is joined.
+func guildCreate(s *discordgo.Session, event *discordgo.GuildCreate) {
+	if event.Guild.Unavailable != nil {
+		return
+	}
+
+	for _, channel := range event.Guild.Channels {
+		if channel.ID == event.Guild.ID {
+			_, _ = s.ChannelMessageSend(channel.ID, "Airhorn is ready! Type !airhorn while in a voice channel to play a sound.")
+			return
+		}
+	}
+}
+
+// loadSound attempts to load an encoded sound file from disk.
+func loadSound() error {
+	file, err := os.Open("airhorn.dca")
+
+	if err != nil {
+		fmt.Println("Error opening dca file :", err)
+		return err
+	}
+
+	var opuslen int16
+
+	for {
+		// Read opus frame length from dca file.
+		err = binary.Read(file, binary.LittleEndian, &opuslen)
+
+		// If this is the end of the file, just return.
+		if err == io.EOF || err == io.ErrUnexpectedEOF {
+			return nil
+		}
+
+		if err != nil {
+			fmt.Println("Error reading from dca file :", err)
+			return err
+		}
+
+		// Read encoded pcm from dca file.
+		InBuf := make([]byte, opuslen)
+		err = binary.Read(file, binary.LittleEndian, &InBuf)
+
+		// Should not be any end of file errors
+		if err != nil {
+			fmt.Println("Error reading from dca file :", err)
+			return err
+		}
+
+		// Append encoded pcm data to the buffer.
+		buffer = append(buffer, InBuf)
+	}
+}
+
+// playSound plays the current buffer to the provided channel.
+func playSound(s *discordgo.Session, guildID, channelID string) (err error) {
+	// Join the provided voice channel.
+	vc, err := s.ChannelVoiceJoin(guildID, channelID, false, true)
+	if err != nil {
+		return err
+	}
+
+	// Sleep for a specified amount of time before playing the sound
+	time.Sleep(250 * time.Millisecond)
+
+	// Start speaking.
+	_ = vc.Speaking(true)
+
+	// Send the buffer data.
+	for _, buff := range buffer {
+		vc.OpusSend <- buff
+	}
+
+	// Stop speaking
+	_ = vc.Speaking(false)
+
+	// Sleep for a specificed amount of time before ending.
+	time.Sleep(250 * time.Millisecond)
+
+	// Disconnect from the provided voice channel.
+	_ = vc.Disconnect()
+
+	return nil
+}

vendor/github.com/bwmarrin/discordgo/examples/appmaker/main.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Variables used for command line options
+var (
+	Email    string
+	Password string
+	Token    string
+	AppName  string
+	DeleteID string
+	ListOnly bool
+)
+
+func init() {
+
+	flag.StringVar(&Email, "e", "", "Account Email")
+	flag.StringVar(&Password, "p", "", "Account Password")
+	flag.StringVar(&Token, "t", "", "Account Token")
+	flag.StringVar(&DeleteID, "d", "", "Application ID to delete")
+	flag.BoolVar(&ListOnly, "l", false, "List Applications Only")
+	flag.StringVar(&AppName, "a", "", "App/Bot Name")
+	flag.Parse()
+}
+
+func main() {
+
+	var err error
+	// Create a new Discord session using the provided login information.
+	dg, err := discordgo.New(Email, Password, Token)
+	if err != nil {
+		fmt.Println("error creating Discord session,", err)
+		return
+	}
+
+	// If -l set, only display a list of existing applications
+	// for the given account.
+	if ListOnly {
+		aps, err2 := dg.Applications()
+		if err2 != nil {
+			fmt.Println("error fetching applications,", err)
+			return
+		}
+
+		for k, v := range aps {
+			fmt.Printf("%d : --------------------------------------\n", k)
+			fmt.Printf("ID: %s\n", v.ID)
+			fmt.Printf("Name: %s\n", v.Name)
+			fmt.Printf("Secret: %s\n", v.Secret)
+			fmt.Printf("Description: %s\n", v.Description)
+		}
+		return
+	}
+
+	// if -d set, delete the given Application
+	if DeleteID != "" {
+		err = dg.ApplicationDelete(DeleteID)
+		if err != nil {
+			fmt.Println("error deleting application,", err)
+		}
+		return
+	}
+
+	// Create a new application.
+	ap := &discordgo.Application{}
+	ap.Name = AppName
+	ap, err = dg.ApplicationCreate(ap)
+	if err != nil {
+		fmt.Println("error creating new applicaiton,", err)
+		return
+	}
+
+	fmt.Printf("Application created successfully:\n")
+	fmt.Printf("ID: %s\n", ap.ID)
+	fmt.Printf("Name: %s\n", ap.Name)
+	fmt.Printf("Secret: %s\n\n", ap.Secret)
+
+	// Create the bot account under the application we just created
+	bot, err := dg.ApplicationBotCreate(ap.ID)
+	if err != nil {
+		fmt.Println("error creating bot account,", err)
+		return
+	}
+
+	fmt.Printf("Bot account created successfully.\n")
+	fmt.Printf("ID: %s\n", bot.ID)
+	fmt.Printf("Username: %s\n", bot.Username)
+	fmt.Printf("Token: %s\n\n", bot.Token)
+	fmt.Println("Please save the above posted info in a secure place.")
+	fmt.Println("You will need that information to login with your bot account.")
+
+	return
+}

vendor/github.com/bwmarrin/discordgo/examples/avatar/localfile/main.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"encoding/base64"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Variables used for command line parameters
+var (
+	Email       string
+	Password    string
+	Token       string
+	Avatar      string
+	BotID       string
+	BotUsername string
+)
+
+func init() {
+
+	flag.StringVar(&Email, "e", "", "Account Email")
+	flag.StringVar(&Password, "p", "", "Account Password")
+	flag.StringVar(&Token, "t", "", "Account Token")
+	flag.StringVar(&Avatar, "f", "./avatar.jpg", "Avatar File Name")
+	flag.Parse()
+}
+
+func main() {
+
+	// Create a new Discord session using the provided login information.
+	// Use discordgo.New(Token) to just use a token for login.
+	dg, err := discordgo.New(Email, Password, Token)
+	if err != nil {
+		fmt.Println("error creating Discord session,", err)
+		return
+	}
+
+	bot, err := dg.User("@me")
+	if err != nil {
+		fmt.Println("error fetching the bot details,", err)
+		return
+	}
+
+	BotID = bot.ID
+	BotUsername = bot.Username
+	changeAvatar(dg)
+
+	fmt.Println("Bot is now running.  Press CTRL-C to exit.")
+	// Simple way to keep program running until CTRL-C is pressed.
+	<-make(chan struct{})
+	return
+}
+
+// Helper function to change the avatar
+func changeAvatar(s *discordgo.Session) {
+	img, err := ioutil.ReadFile(Avatar)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	base64 := base64.StdEncoding.EncodeToString(img)
+
+	avatar := fmt.Sprintf("data:%s;base64,%s", http.DetectContentType(img), base64)
+
+	_, err = s.UserUpdate("", "", BotUsername, avatar, "")
+	if err != nil {
+		fmt.Println(err)
+	}
+}

vendor/github.com/bwmarrin/discordgo/examples/avatar/url/main.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"encoding/base64"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Variables used for command line parameters
+var (
+	Email       string
+	Password    string
+	Token       string
+	URL         string
+	BotID       string
+	BotUsername string
+)
+
+func init() {
+
+	flag.StringVar(&Email, "e", "", "Account Email")
+	flag.StringVar(&Password, "p", "", "Account Password")
+	flag.StringVar(&Token, "t", "", "Account Token")
+	flag.StringVar(&URL, "l", "http://bwmarrin.github.io/discordgo/img/discordgo.png", "Link to the avatar image")
+	flag.Parse()
+}
+
+func main() {
+
+	// Create a new Discord session using the provided login information.
+	// Use discordgo.New(Token) to just use a token for login.
+	dg, err := discordgo.New(Email, Password, Token)
+	if err != nil {
+		fmt.Println("error creating Discord session,", err)
+		return
+	}
+
+	bot, err := dg.User("@me")
+	if err != nil {
+		fmt.Println("error fetching the bot details,", err)
+		return
+	}
+
+	BotID = bot.ID
+	BotUsername = bot.Username
+	changeAvatar(dg)
+
+	fmt.Println("Bot is now running.  Press CTRL-C to exit.")
+	// Simple way to keep program running until CTRL-C is pressed.
+	<-make(chan struct{})
+	return
+}
+
+// Helper function to change the avatar
+func changeAvatar(s *discordgo.Session) {
+
+	resp, err := http.Get(URL)
+	if err != nil {
+		fmt.Println("Error retrieving the file, ", err)
+		return
+	}
+
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+
+	img, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		fmt.Println("Error reading the response, ", err)
+		return
+	}
+
+	base64 := base64.StdEncoding.EncodeToString(img)
+
+	avatar := fmt.Sprintf("data:%s;base64,%s", http.DetectContentType(img), base64)
+
+	_, err = s.UserUpdate("", "", BotUsername, avatar, "")
+	if err != nil {
+		fmt.Println("Error setting the avatar, ", err)
+	}
+
+}

vendor/github.com/bwmarrin/discordgo/examples/mytoken/main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Variables used for command line parameters
+var (
+	Email    string
+	Password string
+)
+
+func init() {
+
+	flag.StringVar(&Email, "e", "", "Account Email")
+	flag.StringVar(&Password, "p", "", "Account Password")
+	flag.Parse()
+}
+
+func main() {
+
+	// Create a new Discord session using the provided login information.
+	dg, err := discordgo.New(Email, Password)
+	if err != nil {
+		fmt.Println("error creating Discord session,", err)
+		return
+	}
+
+	fmt.Printf("Your Authentication Token is:\n\n%s\n", dg.Token)
+}

vendor/github.com/bwmarrin/discordgo/examples/new_basic/main.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Variables used for command line parameters
+var (
+	Email    string
+	Password string
+	Token    string
+)
+
+func init() {
+
+	flag.StringVar(&Email, "e", "", "Account Email")
+	flag.StringVar(&Password, "p", "", "Account Password")
+	flag.StringVar(&Token, "t", "", "Account Token")
+	flag.Parse()
+}
+
+func main() {
+
+	// Create a new Discord session using the provided login information.
+	// Use discordgo.New(Token) to just use a token for login.
+	dg, err := discordgo.New(Email, Password, Token)
+	if err != nil {
+		fmt.Println("error creating Discord session,", err)
+		return
+	}
+
+	// Register messageCreate as a callback for the messageCreate events.
+	dg.AddHandler(messageCreate)
+
+	// Open the websocket and begin listening.
+	err = dg.Open()
+	if err != nil {
+		fmt.Println("error opening connection,", err)
+		return
+	}
+
+	fmt.Println("Bot is now running.  Press CTRL-C to exit.")
+	// Simple way to keep program running until CTRL-C is pressed.
+	<-make(chan struct{})
+	return
+}
+
+// This function will be called (due to AddHandler above) every time a new
+// message is created on any channel that the autenticated bot has access to.
+func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+
+	// Print message to stdout.
+	fmt.Printf("%20s %20s %20s > %s\n", m.ChannelID, time.Now().Format(time.Stamp), m.Author.Username, m.Content)
+}

vendor/github.com/bwmarrin/discordgo/examples/pingpong/main.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Variables used for command line parameters
+var (
+	Email    string
+	Password string
+	Token    string
+	BotID    string
+)
+
+func init() {
+
+	flag.StringVar(&Email, "e", "", "Account Email")
+	flag.StringVar(&Password, "p", "", "Account Password")
+	flag.StringVar(&Token, "t", "", "Account Token")
+	flag.Parse()
+}
+
+func main() {
+
+	// Create a new Discord session using the provided login information.
+	dg, err := discordgo.New(Email, Password, Token)
+	if err != nil {
+		fmt.Println("error creating Discord session,", err)
+		return
+	}
+
+	// Get the account information.
+	u, err := dg.User("@me")
+	if err != nil {
+		fmt.Println("error obtaining account details,", err)
+	}
+
+	// Store the account ID for later use.
+	BotID = u.ID
+
+	// Register messageCreate as a callback for the messageCreate events.
+	dg.AddHandler(messageCreate)
+
+	// Open the websocket and begin listening.
+	err = dg.Open()
+	if err != nil {
+		fmt.Println("error opening connection,", err)
+		return
+	}
+
+	fmt.Println("Bot is now running.  Press CTRL-C to exit.")
+	// Simple way to keep program running until CTRL-C is pressed.
+	<-make(chan struct{})
+	return
+}
+
+// This function will be called (due to AddHandler above) every time a new
+// message is created on any channel that the autenticated bot has access to.
+func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+
+	// Ignore all messages created by the bot itself
+	if m.Author.ID == BotID {
+		return
+	}
+
+	// If the message is "ping" reply with "Pong!"
+	if m.Content == "ping" {
+		_, _ = s.ChannelMessageSend(m.ChannelID, "Pong!")
+	}
+
+	// If the message is "pong" reply with "Ping!"
+	if m.Content == "pong" {
+		_, _ = s.ChannelMessageSend(m.ChannelID, "Ping!")
+	}
+}

vendor/github.com/bwmarrin/discordgo/logging.go

@@ -0,0 +1,95 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains code related to discordgo package logging
+
+package discordgo
+
+import (
+	"fmt"
+	"log"
+	"runtime"
+	"strings"
+)
+
+const (
+
+	// LogError level is used for critical errors that could lead to data loss
+	// or panic that would not be returned to a calling function.
+	LogError int = iota
+
+	// LogWarning level is used for very abnormal events and errors that are
+	// also returend to a calling function.
+	LogWarning
+
+	// LogInformational level is used for normal non-error activity
+	LogInformational
+
+	// LogDebug level is for very detailed non-error activity.  This is
+	// very spammy and will impact performance.
+	LogDebug
+)
+
+// msglog provides package wide logging consistancy for discordgo
+// the format, a...  portion this command follows that of fmt.Printf
+//   msgL   : LogLevel of the message
+//   caller : 1 + the number of callers away from the message source
+//   format : Printf style message format
+//   a ...  : comma seperated list of values to pass
+func msglog(msgL, caller int, format string, a ...interface{}) {
+
+	pc, file, line, _ := runtime.Caller(caller)
+
+	files := strings.Split(file, "/")
+	file = files[len(files)-1]
+
+	name := runtime.FuncForPC(pc).Name()
+	fns := strings.Split(name, ".")
+	name = fns[len(fns)-1]
+
+	msg := fmt.Sprintf(format, a...)
+
+	log.Printf("[DG%d] %s:%d:%s() %s\n", msgL, file, line, name, msg)
+}
+
+// helper function that wraps msglog for the Session struct
+// This adds a check to insure the message is only logged
+// if the session log level is equal or higher than the
+// message log level
+func (s *Session) log(msgL int, format string, a ...interface{}) {
+
+	if msgL > s.LogLevel {
+		return
+	}
+
+	msglog(msgL, 2, format, a...)
+}
+
+// helper function that wraps msglog for the VoiceConnection struct
+// This adds a check to insure the message is only logged
+// if the voice connection log level is equal or higher than the
+// message log level
+func (v *VoiceConnection) log(msgL int, format string, a ...interface{}) {
+
+	if msgL > v.LogLevel {
+		return
+	}
+
+	msglog(msgL, 2, format, a...)
+}
+
+// printJSON is a helper function to display JSON data in a easy to read format.
+/* NOT USED ATM
+func printJSON(body []byte) {
+	var prettyJSON bytes.Buffer
+	error := json.Indent(&prettyJSON, body, "", "\t")
+	if error != nil {
+		log.Print("JSON parse error: ", error)
+	}
+	log.Println(string(prettyJSON.Bytes()))
+}
+*/

vendor/github.com/bwmarrin/discordgo/message.go

@@ -0,0 +1,82 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains code related to the Message struct
+
+package discordgo
+
+import (
+	"fmt"
+	"regexp"
+)
+
+// A Message stores all data related to a specific Discord message.
+type Message struct {
+	ID              string               `json:"id"`
+	ChannelID       string               `json:"channel_id"`
+	Content         string               `json:"content"`
+	Timestamp       string               `json:"timestamp"`
+	EditedTimestamp string               `json:"edited_timestamp"`
+	MentionRoles    []string             `json:"mention_roles"`
+	Tts             bool                 `json:"tts"`
+	MentionEveryone bool                 `json:"mention_everyone"`
+	Author          *User                `json:"author"`
+	Attachments     []*MessageAttachment `json:"attachments"`
+	Embeds          []*MessageEmbed      `json:"embeds"`
+	Mentions        []*User              `json:"mentions"`
+}
+
+// A MessageAttachment stores data for message attachments.
+type MessageAttachment struct {
+	ID       string `json:"id"`
+	URL      string `json:"url"`
+	ProxyURL string `json:"proxy_url"`
+	Filename string `json:"filename"`
+	Width    int    `json:"width"`
+	Height   int    `json:"height"`
+	Size     int    `json:"size"`
+}
+
+// An MessageEmbed stores data for message embeds.
+type MessageEmbed struct {
+	URL         string `json:"url"`
+	Type        string `json:"type"`
+	Title       string `json:"title"`
+	Description string `json:"description"`
+	Thumbnail   *struct {
+		URL      string `json:"url"`
+		ProxyURL string `json:"proxy_url"`
+		Width    int    `json:"width"`
+		Height   int    `json:"height"`
+	} `json:"thumbnail"`
+	Provider *struct {
+		URL  string `json:"url"`
+		Name string `json:"name"`
+	} `json:"provider"`
+	Author *struct {
+		URL  string `json:"url"`
+		Name string `json:"name"`
+	} `json:"author"`
+	Video *struct {
+		URL    string `json:"url"`
+		Width  int    `json:"width"`
+		Height int    `json:"height"`
+	} `json:"video"`
+}
+
+// ContentWithMentionsReplaced will replace all @<id> mentions with the
+// username of the mention.
+func (m *Message) ContentWithMentionsReplaced() string {
+	if m.Mentions == nil {
+		return m.Content
+	}
+	content := m.Content
+	for _, user := range m.Mentions {
+		content = regexp.MustCompile(fmt.Sprintf("<@!?(%s)>", user.ID)).ReplaceAllString(content, "@"+user.Username)
+	}
+	return content
+}

vendor/github.com/bwmarrin/discordgo/oauth2.go

@@ -0,0 +1,120 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains functions related to Discord OAuth2 endpoints
+
+package discordgo
+
+// ------------------------------------------------------------------------------------------------
+// Code specific to Discord OAuth2 Applications
+// ------------------------------------------------------------------------------------------------
+
+// An Application struct stores values for a Discord OAuth2 Application
+type Application struct {
+	ID           string    `json:"id,omitempty"`
+	Name         string    `json:"name"`
+	Description  string    `json:"description,omitempty"`
+	Icon         string    `json:"icon,omitempty"`
+	Secret       string    `json:"secret,omitempty"`
+	RedirectURIs *[]string `json:"redirect_uris,omitempty"`
+}
+
+// Application returns an Application structure of a specific Application
+//   appID : The ID of an Application
+func (s *Session) Application(appID string) (st *Application, err error) {
+
+	body, err := s.Request("GET", EndpointApplication(appID), nil)
+	if err != nil {
+		return
+	}
+
+	err = unmarshal(body, &st)
+	return
+}
+
+// Applications returns all applications for the authenticated user
+func (s *Session) Applications() (st []*Application, err error) {
+
+	body, err := s.Request("GET", EndpointApplications, nil)
+	if err != nil {
+		return
+	}
+
+	err = unmarshal(body, &st)
+	return
+}
+
+// ApplicationCreate creates a new Application
+//    name : Name of Application / Bot
+//    uris : Redirect URIs (Not required)
+func (s *Session) ApplicationCreate(ap *Application) (st *Application, err error) {
+
+	data := struct {
+		Name         string    `json:"name"`
+		Description  string    `json:"description"`
+		RedirectURIs *[]string `json:"redirect_uris,omitempty"`
+	}{ap.Name, ap.Description, ap.RedirectURIs}
+
+	body, err := s.Request("POST", EndpointApplications, data)
+	if err != nil {
+		return
+	}
+
+	err = unmarshal(body, &st)
+	return
+}
+
+// ApplicationUpdate updates an existing Application
+//   var : desc
+func (s *Session) ApplicationUpdate(appID string, ap *Application) (st *Application, err error) {
+
+	data := struct {
+		Name         string    `json:"name"`
+		Description  string    `json:"description"`
+		RedirectURIs *[]string `json:"redirect_uris,omitempty"`
+	}{ap.Name, ap.Description, ap.RedirectURIs}
+
+	body, err := s.Request("PUT", EndpointApplication(appID), data)
+	if err != nil {
+		return
+	}
+
+	err = unmarshal(body, &st)
+	return
+}
+
+// ApplicationDelete deletes an existing Application
+//   appID : The ID of an Application
+func (s *Session) ApplicationDelete(appID string) (err error) {
+
+	_, err = s.Request("DELETE", EndpointApplication(appID), nil)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ------------------------------------------------------------------------------------------------
+// Code specific to Discord OAuth2 Application Bots
+// ------------------------------------------------------------------------------------------------
+
+// ApplicationBotCreate creates an Application Bot Account
+//
+//   appID : The ID of an Application
+//
+// NOTE: func name may change, if I can think up something better.
+func (s *Session) ApplicationBotCreate(appID string) (st *User, err error) {
+
+	body, err := s.Request("POST", EndpointApplicationsBot(appID), nil)
+	if err != nil {
+		return
+	}
+
+	err = unmarshal(body, &st)
+	return
+}

vendor/github.com/bwmarrin/discordgo/state.go

@@ -0,0 +1,746 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains code related to state tracking.  If enabled, state
+// tracking will capture the initial READY packet and many other websocket
+// events and maintain an in-memory state of of guilds, channels, users, and
+// so forth.  This information can be accessed through the Session.State struct.
+
+package discordgo
+
+import (
+	"errors"
+	"sync"
+)
+
+// ErrNilState is returned when the state is nil.
+var ErrNilState = errors.New("State not instantiated, please use discordgo.New() or assign Session.State.")
+
+// A State contains the current known state.
+// As discord sends this in a READY blob, it seems reasonable to simply
+// use that struct as the data store.
+type State struct {
+	sync.RWMutex
+	Ready
+
+	MaxMessageCount int
+	TrackChannels   bool
+	TrackEmojis     bool
+	TrackMembers    bool
+	TrackRoles      bool
+	TrackVoice      bool
+
+	guildMap   map[string]*Guild
+	channelMap map[string]*Channel
+}
+
+// NewState creates an empty state.
+func NewState() *State {
+	return &State{
+		Ready: Ready{
+			PrivateChannels: []*Channel{},
+			Guilds:          []*Guild{},
+		},
+		TrackChannels: true,
+		TrackEmojis:   true,
+		TrackMembers:  true,
+		TrackRoles:    true,
+		TrackVoice:    true,
+		guildMap:      make(map[string]*Guild),
+		channelMap:    make(map[string]*Channel),
+	}
+}
+
+// OnReady takes a Ready event and updates all internal state.
+func (s *State) OnReady(r *Ready) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	s.Ready = *r
+
+	for _, g := range s.Guilds {
+		s.guildMap[g.ID] = g
+
+		for _, c := range g.Channels {
+			c.GuildID = g.ID
+			s.channelMap[c.ID] = c
+		}
+	}
+
+	for _, c := range s.PrivateChannels {
+		s.channelMap[c.ID] = c
+	}
+
+	return nil
+}
+
+// GuildAdd adds a guild to the current world state, or
+// updates it if it already exists.
+func (s *State) GuildAdd(guild *Guild) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	// Update the channels to point to the right guild, adding them to the channelMap as we go
+	for _, c := range guild.Channels {
+		c.GuildID = guild.ID
+		s.channelMap[c.ID] = c
+	}
+
+	// If the guild exists, replace it.
+	if g, ok := s.guildMap[guild.ID]; ok {
+		// If this guild already exists with data, don't stomp on props.
+		if g.Unavailable != nil && !*g.Unavailable {
+			guild.Members = g.Members
+			guild.Presences = g.Presences
+			guild.Channels = g.Channels
+			guild.VoiceStates = g.VoiceStates
+		}
+
+		*g = *guild
+		return nil
+	}
+
+	s.Guilds = append(s.Guilds, guild)
+	s.guildMap[guild.ID] = guild
+
+	return nil
+}
+
+// GuildRemove removes a guild from current world state.
+func (s *State) GuildRemove(guild *Guild) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	_, err := s.Guild(guild.ID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	delete(s.guildMap, guild.ID)
+
+	for i, g := range s.Guilds {
+		if g.ID == guild.ID {
+			s.Guilds = append(s.Guilds[:i], s.Guilds[i+1:]...)
+			return nil
+		}
+	}
+
+	return nil
+}
+
+// Guild gets a guild by ID.
+// Useful for querying if @me is in a guild:
+//     _, err := discordgo.Session.State.Guild(guildID)
+//     isInGuild := err == nil
+func (s *State) Guild(guildID string) (*Guild, error) {
+	if s == nil {
+		return nil, ErrNilState
+	}
+
+	s.RLock()
+	defer s.RUnlock()
+
+	if g, ok := s.guildMap[guildID]; ok {
+		return g, nil
+	}
+
+	return nil, errors.New("Guild not found.")
+}
+
+// TODO: Consider moving Guild state update methods onto *Guild.
+
+// MemberAdd adds a member to the current world state, or
+// updates it if it already exists.
+func (s *State) MemberAdd(member *Member) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	guild, err := s.Guild(member.GuildID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	for i, m := range guild.Members {
+		if m.User.ID == member.User.ID {
+			guild.Members[i] = member
+			return nil
+		}
+	}
+
+	guild.Members = append(guild.Members, member)
+	return nil
+}
+
+// MemberRemove removes a member from current world state.
+func (s *State) MemberRemove(member *Member) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	guild, err := s.Guild(member.GuildID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	for i, m := range guild.Members {
+		if m.User.ID == member.User.ID {
+			guild.Members = append(guild.Members[:i], guild.Members[i+1:]...)
+			return nil
+		}
+	}
+
+	return errors.New("Member not found.")
+}
+
+// Member gets a member by ID from a guild.
+func (s *State) Member(guildID, userID string) (*Member, error) {
+	if s == nil {
+		return nil, ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return nil, err
+	}
+
+	s.RLock()
+	defer s.RUnlock()
+
+	for _, m := range guild.Members {
+		if m.User.ID == userID {
+			return m, nil
+		}
+	}
+
+	return nil, errors.New("Member not found.")
+}
+
+// RoleAdd adds a role to the current world state, or
+// updates it if it already exists.
+func (s *State) RoleAdd(guildID string, role *Role) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	for i, r := range guild.Roles {
+		if r.ID == role.ID {
+			guild.Roles[i] = role
+			return nil
+		}
+	}
+
+	guild.Roles = append(guild.Roles, role)
+	return nil
+}
+
+// RoleRemove removes a role from current world state by ID.
+func (s *State) RoleRemove(guildID, roleID string) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	for i, r := range guild.Roles {
+		if r.ID == roleID {
+			guild.Roles = append(guild.Roles[:i], guild.Roles[i+1:]...)
+			return nil
+		}
+	}
+
+	return errors.New("Role not found.")
+}
+
+// Role gets a role by ID from a guild.
+func (s *State) Role(guildID, roleID string) (*Role, error) {
+	if s == nil {
+		return nil, ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return nil, err
+	}
+
+	s.RLock()
+	defer s.RUnlock()
+
+	for _, r := range guild.Roles {
+		if r.ID == roleID {
+			return r, nil
+		}
+	}
+
+	return nil, errors.New("Role not found.")
+}
+
+// ChannelAdd adds a guild to the current world state, or
+// updates it if it already exists.
+// Channels may exist either as PrivateChannels or inside
+// a guild.
+func (s *State) ChannelAdd(channel *Channel) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	// If the channel exists, replace it
+	if c, ok := s.channelMap[channel.ID]; ok {
+		channel.Messages = c.Messages
+		channel.PermissionOverwrites = c.PermissionOverwrites
+
+		*c = *channel
+		return nil
+	}
+
+	if channel.IsPrivate {
+		s.PrivateChannels = append(s.PrivateChannels, channel)
+	} else {
+		guild, ok := s.guildMap[channel.GuildID]
+		if !ok {
+			return errors.New("Guild for channel not found.")
+		}
+
+		guild.Channels = append(guild.Channels, channel)
+	}
+
+	s.channelMap[channel.ID] = channel
+
+	return nil
+}
+
+// ChannelRemove removes a channel from current world state.
+func (s *State) ChannelRemove(channel *Channel) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	_, err := s.Channel(channel.ID)
+	if err != nil {
+		return err
+	}
+
+	if channel.IsPrivate {
+		s.Lock()
+		defer s.Unlock()
+
+		for i, c := range s.PrivateChannels {
+			if c.ID == channel.ID {
+				s.PrivateChannels = append(s.PrivateChannels[:i], s.PrivateChannels[i+1:]...)
+				break
+			}
+		}
+	} else {
+		guild, err := s.Guild(channel.GuildID)
+		if err != nil {
+			return err
+		}
+
+		s.Lock()
+		defer s.Unlock()
+
+		for i, c := range guild.Channels {
+			if c.ID == channel.ID {
+				guild.Channels = append(guild.Channels[:i], guild.Channels[i+1:]...)
+				break
+			}
+		}
+	}
+
+	delete(s.channelMap, channel.ID)
+
+	return nil
+}
+
+// GuildChannel gets a channel by ID from a guild.
+// This method is Deprecated, use Channel(channelID)
+func (s *State) GuildChannel(guildID, channelID string) (*Channel, error) {
+	return s.Channel(channelID)
+}
+
+// PrivateChannel gets a private channel by ID.
+// This method is Deprecated, use Channel(channelID)
+func (s *State) PrivateChannel(channelID string) (*Channel, error) {
+	return s.Channel(channelID)
+}
+
+// Channel gets a channel by ID, it will look in all guilds an private channels.
+func (s *State) Channel(channelID string) (*Channel, error) {
+	if s == nil {
+		return nil, ErrNilState
+	}
+
+	s.RLock()
+	defer s.RUnlock()
+
+	if c, ok := s.channelMap[channelID]; ok {
+		return c, nil
+	}
+
+	return nil, errors.New("Channel not found.")
+}
+
+// Emoji returns an emoji for a guild and emoji id.
+func (s *State) Emoji(guildID, emojiID string) (*Emoji, error) {
+	if s == nil {
+		return nil, ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return nil, err
+	}
+
+	s.RLock()
+	defer s.RUnlock()
+
+	for _, e := range guild.Emojis {
+		if e.ID == emojiID {
+			return e, nil
+		}
+	}
+
+	return nil, errors.New("Emoji not found.")
+}
+
+// EmojiAdd adds an emoji to the current world state.
+func (s *State) EmojiAdd(guildID string, emoji *Emoji) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	for i, e := range guild.Emojis {
+		if e.ID == emoji.ID {
+			guild.Emojis[i] = emoji
+			return nil
+		}
+	}
+
+	guild.Emojis = append(guild.Emojis, emoji)
+	return nil
+}
+
+// EmojisAdd adds multiple emojis to the world state.
+func (s *State) EmojisAdd(guildID string, emojis []*Emoji) error {
+	for _, e := range emojis {
+		if err := s.EmojiAdd(guildID, e); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// MessageAdd adds a message to the current world state, or updates it if it exists.
+// If the channel cannot be found, the message is discarded.
+// Messages are kept in state up to s.MaxMessageCount
+func (s *State) MessageAdd(message *Message) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	c, err := s.Channel(message.ChannelID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	// If the message exists, merge in the new message contents.
+	for _, m := range c.Messages {
+		if m.ID == message.ID {
+			if message.Content != "" {
+				m.Content = message.Content
+			}
+			if message.EditedTimestamp != "" {
+				m.EditedTimestamp = message.EditedTimestamp
+			}
+			if message.Mentions != nil {
+				m.Mentions = message.Mentions
+			}
+			if message.Embeds != nil {
+				m.Embeds = message.Embeds
+			}
+			if message.Attachments != nil {
+				m.Attachments = message.Attachments
+			}
+
+			return nil
+		}
+	}
+
+	c.Messages = append(c.Messages, message)
+
+	if len(c.Messages) > s.MaxMessageCount {
+		c.Messages = c.Messages[len(c.Messages)-s.MaxMessageCount:]
+	}
+	return nil
+}
+
+// MessageRemove removes a message from the world state.
+func (s *State) MessageRemove(message *Message) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	c, err := s.Channel(message.ChannelID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	for i, m := range c.Messages {
+		if m.ID == message.ID {
+			c.Messages = append(c.Messages[:i], c.Messages[i+1:]...)
+			return nil
+		}
+	}
+
+	return errors.New("Message not found.")
+}
+
+func (s *State) voiceStateUpdate(update *VoiceStateUpdate) error {
+	guild, err := s.Guild(update.GuildID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	// Handle Leaving Channel
+	if update.ChannelID == "" {
+		for i, state := range guild.VoiceStates {
+			if state.UserID == update.UserID {
+				guild.VoiceStates = append(guild.VoiceStates[:i], guild.VoiceStates[i+1:]...)
+				return nil
+			}
+		}
+	} else {
+		for i, state := range guild.VoiceStates {
+			if state.UserID == update.UserID {
+				guild.VoiceStates[i] = update.VoiceState
+				return nil
+			}
+		}
+
+		guild.VoiceStates = append(guild.VoiceStates, update.VoiceState)
+	}
+
+	return nil
+}
+
+// Message gets a message by channel and message ID.
+func (s *State) Message(channelID, messageID string) (*Message, error) {
+	if s == nil {
+		return nil, ErrNilState
+	}
+
+	c, err := s.Channel(channelID)
+	if err != nil {
+		return nil, err
+	}
+
+	s.RLock()
+	defer s.RUnlock()
+
+	for _, m := range c.Messages {
+		if m.ID == messageID {
+			return m, nil
+		}
+	}
+
+	return nil, errors.New("Message not found.")
+}
+
+// onInterface handles all events related to states.
+func (s *State) onInterface(se *Session, i interface{}) (err error) {
+	if s == nil {
+		return ErrNilState
+	}
+	if !se.StateEnabled {
+		return nil
+	}
+
+	switch t := i.(type) {
+	case *Ready:
+		err = s.OnReady(t)
+	case *GuildCreate:
+		err = s.GuildAdd(t.Guild)
+	case *GuildUpdate:
+		err = s.GuildAdd(t.Guild)
+	case *GuildDelete:
+		err = s.GuildRemove(t.Guild)
+	case *GuildMemberAdd:
+		if s.TrackMembers {
+			err = s.MemberAdd(t.Member)
+		}
+	case *GuildMemberUpdate:
+		if s.TrackMembers {
+			err = s.MemberAdd(t.Member)
+		}
+	case *GuildMemberRemove:
+		if s.TrackMembers {
+			err = s.MemberRemove(t.Member)
+		}
+	case *GuildRoleCreate:
+		if s.TrackRoles {
+			err = s.RoleAdd(t.GuildID, t.Role)
+		}
+	case *GuildRoleUpdate:
+		if s.TrackRoles {
+			err = s.RoleAdd(t.GuildID, t.Role)
+		}
+	case *GuildRoleDelete:
+		if s.TrackRoles {
+			err = s.RoleRemove(t.GuildID, t.RoleID)
+		}
+	case *GuildEmojisUpdate:
+		if s.TrackEmojis {
+			err = s.EmojisAdd(t.GuildID, t.Emojis)
+		}
+	case *ChannelCreate:
+		if s.TrackChannels {
+			err = s.ChannelAdd(t.Channel)
+		}
+	case *ChannelUpdate:
+		if s.TrackChannels {
+			err = s.ChannelAdd(t.Channel)
+		}
+	case *ChannelDelete:
+		if s.TrackChannels {
+			err = s.ChannelRemove(t.Channel)
+		}
+	case *MessageCreate:
+		if s.MaxMessageCount != 0 {
+			err = s.MessageAdd(t.Message)
+		}
+	case *MessageUpdate:
+		if s.MaxMessageCount != 0 {
+			err = s.MessageAdd(t.Message)
+		}
+	case *MessageDelete:
+		if s.MaxMessageCount != 0 {
+			err = s.MessageRemove(t.Message)
+		}
+	case *VoiceStateUpdate:
+		if s.TrackVoice {
+			err = s.voiceStateUpdate(t)
+		}
+	}
+
+	return
+}
+
+// UserChannelPermissions returns the permission of a user in a channel.
+// userID    : The ID of the user to calculate permissions for.
+// channelID : The ID of the channel to calculate permission for.
+func (s *State) UserChannelPermissions(userID, channelID string) (apermissions int, err error) {
+
+	channel, err := s.Channel(channelID)
+	if err != nil {
+		return
+	}
+
+	guild, err := s.Guild(channel.GuildID)
+	if err != nil {
+		return
+	}
+
+	if userID == guild.OwnerID {
+		apermissions = PermissionAll
+		return
+	}
+
+	member, err := s.Member(guild.ID, userID)
+	if err != nil {
+		return
+	}
+
+	for _, role := range guild.Roles {
+		for _, roleID := range member.Roles {
+			if role.ID == roleID {
+				apermissions |= role.Permissions
+				break
+			}
+		}
+	}
+
+	if apermissions&PermissionManageRoles > 0 {
+		apermissions |= PermissionAll
+	}
+
+	// Member overwrites can override role overrides, so do two passes
+	for _, overwrite := range channel.PermissionOverwrites {
+		for _, roleID := range member.Roles {
+			if overwrite.Type == "role" && roleID == overwrite.ID {
+				apermissions &= ^overwrite.Deny
+				apermissions |= overwrite.Allow
+				break
+			}
+		}
+	}
+
+	for _, overwrite := range channel.PermissionOverwrites {
+		if overwrite.Type == "member" && overwrite.ID == userID {
+			apermissions &= ^overwrite.Deny
+			apermissions |= overwrite.Allow
+			break
+		}
+	}
+
+	if apermissions&PermissionManageRoles > 0 {
+		apermissions |= PermissionAllChannel
+	}
+
+	return
+}

vendor/github.com/bwmarrin/discordgo/structs.go

@@ -0,0 +1,521 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains all structures for the discordgo package.  These
+// may be moved about later into separate files but I find it easier to have
+// them all located together.
+
+package discordgo
+
+import (
+	"encoding/json"
+	"reflect"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// A Session represents a connection to the Discord API.
+type Session struct {
+	sync.RWMutex
+
+	// General configurable settings.
+
+	// Authentication token for this session
+	Token string
+
+	// Debug for printing JSON request/responses
+	Debug    bool // Deprecated, will be removed.
+	LogLevel int
+
+	// Should the session reconnect the websocket on errors.
+	ShouldReconnectOnError bool
+
+	// Should the session request compressed websocket data.
+	Compress bool
+
+	// Sharding
+	ShardID    int
+	ShardCount int
+
+	// Should state tracking be enabled.
+	// State tracking is the best way for getting the the users
+	// active guilds and the members of the guilds.
+	StateEnabled bool
+
+	// Exposed but should not be modified by User.
+
+	// Whether the Data Websocket is ready
+	DataReady bool // NOTE: Maye be deprecated soon
+
+	// Status stores the currect status of the websocket connection
+	// this is being tested, may stay, may go away.
+	status int32
+
+	// Whether the Voice Websocket is ready
+	VoiceReady bool // NOTE: Deprecated.
+
+	// Whether the UDP Connection is ready
+	UDPReady bool // NOTE: Deprecated
+
+	// Stores a mapping of guild id's to VoiceConnections
+	VoiceConnections map[string]*VoiceConnection
+
+	// Managed state object, updated internally with events when
+	// StateEnabled is true.
+	State *State
+
+	handlersMu sync.RWMutex
+	// This is a mapping of event struct to a reflected value
+	// for event handlers.
+	// We store the reflected value instead of the function
+	// reference as it is more performant, instead of re-reflecting
+	// the function each event.
+	handlers map[interface{}][]reflect.Value
+
+	// The websocket connection.
+	wsConn *websocket.Conn
+
+	// When nil, the session is not listening.
+	listening chan interface{}
+
+	// used to deal with rate limits
+	// may switch to slices later
+	// TODO: performance test map vs slices
+	rateLimit rateLimitMutex
+
+	// sequence tracks the current gateway api websocket sequence number
+	sequence int
+
+	// stores sessions current Discord Gateway
+	gateway string
+
+	// stores session ID of current Gateway connection
+	sessionID string
+
+	// used to make sure gateway websocket writes do not happen concurrently
+	wsMutex sync.Mutex
+}
+
+type rateLimitMutex struct {
+	sync.Mutex
+	url map[string]*sync.Mutex
+	// bucket map[string]*sync.Mutex // TODO :)
+}
+
+// A Resumed struct holds the data received in a RESUMED event
+type Resumed struct {
+	HeartbeatInterval time.Duration `json:"heartbeat_interval"`
+	Trace             []string      `json:"_trace"`
+}
+
+// A VoiceRegion stores data for a specific voice region server.
+type VoiceRegion struct {
+	ID       string `json:"id"`
+	Name     string `json:"name"`
+	Hostname string `json:"sample_hostname"`
+	Port     int    `json:"sample_port"`
+}
+
+// A VoiceICE stores data for voice ICE servers.
+type VoiceICE struct {
+	TTL     string       `json:"ttl"`
+	Servers []*ICEServer `json:"servers"`
+}
+
+// A ICEServer stores data for a specific voice ICE server.
+type ICEServer struct {
+	URL        string `json:"url"`
+	Username   string `json:"username"`
+	Credential string `json:"credential"`
+}
+
+// A Invite stores all data related to a specific Discord Guild or Channel invite.
+type Invite struct {
+	Guild     *Guild   `json:"guild"`
+	Channel   *Channel `json:"channel"`
+	Inviter   *User    `json:"inviter"`
+	Code      string   `json:"code"`
+	CreatedAt string   `json:"created_at"` // TODO make timestamp
+	MaxAge    int      `json:"max_age"`
+	Uses      int      `json:"uses"`
+	MaxUses   int      `json:"max_uses"`
+	XkcdPass  string   `json:"xkcdpass"`
+	Revoked   bool     `json:"revoked"`
+	Temporary bool     `json:"temporary"`
+}
+
+// A Channel holds all data related to an individual Discord channel.
+type Channel struct {
+	ID                   string                 `json:"id"`
+	GuildID              string                 `json:"guild_id"`
+	Name                 string                 `json:"name"`
+	Topic                string                 `json:"topic"`
+	Type                 string                 `json:"type"`
+	LastMessageID        string                 `json:"last_message_id"`
+	Position             int                    `json:"position"`
+	Bitrate              int                    `json:"bitrate"`
+	IsPrivate            bool                   `json:"is_private"`
+	Recipient            *User                  `json:"recipient"`
+	Messages             []*Message             `json:"-"`
+	PermissionOverwrites []*PermissionOverwrite `json:"permission_overwrites"`
+}
+
+// A PermissionOverwrite holds permission overwrite data for a Channel
+type PermissionOverwrite struct {
+	ID    string `json:"id"`
+	Type  string `json:"type"`
+	Deny  int    `json:"deny"`
+	Allow int    `json:"allow"`
+}
+
+// Emoji struct holds data related to Emoji's
+type Emoji struct {
+	ID            string   `json:"id"`
+	Name          string   `json:"name"`
+	Roles         []string `json:"roles"`
+	Managed       bool     `json:"managed"`
+	RequireColons bool     `json:"require_colons"`
+}
+
+// VerificationLevel type defination
+type VerificationLevel int
+
+// Constants for VerificationLevel levels from 0 to 3 inclusive
+const (
+	VerificationLevelNone VerificationLevel = iota
+	VerificationLevelLow
+	VerificationLevelMedium
+	VerificationLevelHigh
+)
+
+// A Guild holds all data related to a specific Discord Guild.  Guilds are also
+// sometimes referred to as Servers in the Discord client.
+type Guild struct {
+	ID                          string            `json:"id"`
+	Name                        string            `json:"name"`
+	Icon                        string            `json:"icon"`
+	Region                      string            `json:"region"`
+	AfkChannelID                string            `json:"afk_channel_id"`
+	EmbedChannelID              string            `json:"embed_channel_id"`
+	OwnerID                     string            `json:"owner_id"`
+	JoinedAt                    string            `json:"joined_at"` // make this a timestamp
+	Splash                      string            `json:"splash"`
+	AfkTimeout                  int               `json:"afk_timeout"`
+	VerificationLevel           VerificationLevel `json:"verification_level"`
+	EmbedEnabled                bool              `json:"embed_enabled"`
+	Large                       bool              `json:"large"` // ??
+	DefaultMessageNotifications int               `json:"default_message_notifications"`
+	Roles                       []*Role           `json:"roles"`
+	Emojis                      []*Emoji          `json:"emojis"`
+	Members                     []*Member         `json:"members"`
+	Presences                   []*Presence       `json:"presences"`
+	Channels                    []*Channel        `json:"channels"`
+	VoiceStates                 []*VoiceState     `json:"voice_states"`
+	Unavailable                 *bool             `json:"unavailable"`
+}
+
+// A GuildParams stores all the data needed to update discord guild settings
+type GuildParams struct {
+	Name              string             `json:"name"`
+	Region            string             `json:"region"`
+	VerificationLevel *VerificationLevel `json:"verification_level"`
+}
+
+// A Role stores information about Discord guild member roles.
+type Role struct {
+	ID          string `json:"id"`
+	Name        string `json:"name"`
+	Managed     bool   `json:"managed"`
+	Hoist       bool   `json:"hoist"`
+	Color       int    `json:"color"`
+	Position    int    `json:"position"`
+	Permissions int    `json:"permissions"`
+}
+
+// A VoiceState stores the voice states of Guilds
+type VoiceState struct {
+	UserID    string `json:"user_id"`
+	SessionID string `json:"session_id"`
+	ChannelID string `json:"channel_id"`
+	GuildID   string `json:"guild_id"`
+	Suppress  bool   `json:"suppress"`
+	SelfMute  bool   `json:"self_mute"`
+	SelfDeaf  bool   `json:"self_deaf"`
+	Mute      bool   `json:"mute"`
+	Deaf      bool   `json:"deaf"`
+}
+
+// A Presence stores the online, offline, or idle and game status of Guild members.
+type Presence struct {
+	User   *User  `json:"user"`
+	Status string `json:"status"`
+	Game   *Game  `json:"game"`
+}
+
+// A Game struct holds the name of the "playing .." game for a user
+type Game struct {
+	Name string `json:"name"`
+	Type int    `json:"type"`
+	URL  string `json:"url"`
+}
+
+// A Member stores user information for Guild members.
+type Member struct {
+	GuildID  string   `json:"guild_id"`
+	JoinedAt string   `json:"joined_at"`
+	Nick     string   `json:"nick"`
+	Deaf     bool     `json:"deaf"`
+	Mute     bool     `json:"mute"`
+	User     *User    `json:"user"`
+	Roles    []string `json:"roles"`
+}
+
+// A User stores all data for an individual Discord user.
+type User struct {
+	ID            string `json:"id"`
+	Email         string `json:"email"`
+	Username      string `json:"username"`
+	Avatar        string `json:"Avatar"`
+	Discriminator string `json:"discriminator"`
+	Token         string `json:"token"`
+	Verified      bool   `json:"verified"`
+	MFAEnabled    bool   `json:"mfa_enabled"`
+	Bot           bool   `json:"bot"`
+}
+
+// A Settings stores data for a specific users Discord client settings.
+type Settings struct {
+	RenderEmbeds            bool               `json:"render_embeds"`
+	InlineEmbedMedia        bool               `json:"inline_embed_media"`
+	InlineAttachmentMedia   bool               `json:"inline_attachment_media"`
+	EnableTtsCommand        bool               `json:"enable_tts_command"`
+	MessageDisplayCompact   bool               `json:"message_display_compact"`
+	ShowCurrentGame         bool               `json:"show_current_game"`
+	AllowEmailFriendRequest bool               `json:"allow_email_friend_request"`
+	ConvertEmoticons        bool               `json:"convert_emoticons"`
+	Locale                  string             `json:"locale"`
+	Theme                   string             `json:"theme"`
+	GuildPositions          []string           `json:"guild_positions"`
+	RestrictedGuilds        []string           `json:"restricted_guilds"`
+	FriendSourceFlags       *FriendSourceFlags `json:"friend_source_flags"`
+}
+
+// FriendSourceFlags stores ... TODO :)
+type FriendSourceFlags struct {
+	All           bool `json:"all"`
+	MutualGuilds  bool `json:"mutual_guilds"`
+	MutualFriends bool `json:"mutual_friends"`
+}
+
+// An Event provides a basic initial struct for all websocket event.
+type Event struct {
+	Operation int             `json:"op"`
+	Sequence  int             `json:"s"`
+	Type      string          `json:"t"`
+	RawData   json.RawMessage `json:"d"`
+	Struct    interface{}     `json:"-"`
+}
+
+// A Ready stores all data for the websocket READY event.
+type Ready struct {
+	Version           int           `json:"v"`
+	SessionID         string        `json:"session_id"`
+	HeartbeatInterval time.Duration `json:"heartbeat_interval"`
+	User              *User         `json:"user"`
+	ReadState         []*ReadState  `json:"read_state"`
+	PrivateChannels   []*Channel    `json:"private_channels"`
+	Guilds            []*Guild      `json:"guilds"`
+
+	// Undocumented fields
+	Settings          *Settings            `json:"user_settings"`
+	UserGuildSettings []*UserGuildSettings `json:"user_guild_settings"`
+	Relationships     []*Relationship      `json:"relationships"`
+	Presences         []*Presence          `json:"presences"`
+}
+
+// A Relationship between the logged in user and Relationship.User
+type Relationship struct {
+	User *User  `json:"user"`
+	Type int    `json:"type"` // 1 = friend, 2 = blocked, 3 = incoming friend req, 4 = sent friend req
+	ID   string `json:"id"`
+}
+
+// A TooManyRequests struct holds information received from Discord
+// when receiving a HTTP 429 response.
+type TooManyRequests struct {
+	Bucket     string        `json:"bucket"`
+	Message    string        `json:"message"`
+	RetryAfter time.Duration `json:"retry_after"`
+}
+
+// A ReadState stores data on the read state of channels.
+type ReadState struct {
+	MentionCount  int    `json:"mention_count"`
+	LastMessageID string `json:"last_message_id"`
+	ID            string `json:"id"`
+}
+
+// A TypingStart stores data for the typing start websocket event.
+type TypingStart struct {
+	UserID    string `json:"user_id"`
+	ChannelID string `json:"channel_id"`
+	Timestamp int    `json:"timestamp"`
+}
+
+// A PresenceUpdate stores data for the presence update websocket event.
+type PresenceUpdate struct {
+	Presence
+	GuildID string   `json:"guild_id"`
+	Roles   []string `json:"roles"`
+}
+
+// A MessageAck stores data for the message ack websocket event.
+type MessageAck struct {
+	MessageID string `json:"message_id"`
+	ChannelID string `json:"channel_id"`
+}
+
+// A GuildIntegrationsUpdate stores data for the guild integrations update
+// websocket event.
+type GuildIntegrationsUpdate struct {
+	GuildID string `json:"guild_id"`
+}
+
+// A GuildRole stores data for guild role websocket events.
+type GuildRole struct {
+	Role    *Role  `json:"role"`
+	GuildID string `json:"guild_id"`
+}
+
+// A GuildRoleDelete stores data for the guild role delete websocket event.
+type GuildRoleDelete struct {
+	RoleID  string `json:"role_id"`
+	GuildID string `json:"guild_id"`
+}
+
+// A GuildBan stores data for a guild ban.
+type GuildBan struct {
+	User    *User  `json:"user"`
+	GuildID string `json:"guild_id"`
+}
+
+// A GuildEmojisUpdate stores data for a guild emoji update event.
+type GuildEmojisUpdate struct {
+	GuildID string   `json:"guild_id"`
+	Emojis  []*Emoji `json:"emojis"`
+}
+
+// A GuildIntegration stores data for a guild integration.
+type GuildIntegration struct {
+	ID                string                   `json:"id"`
+	Name              string                   `json:"name"`
+	Type              string                   `json:"type"`
+	Enabled           bool                     `json:"enabled"`
+	Syncing           bool                     `json:"syncing"`
+	RoleID            string                   `json:"role_id"`
+	ExpireBehavior    int                      `json:"expire_behavior"`
+	ExpireGracePeriod int                      `json:"expire_grace_period"`
+	User              *User                    `json:"user"`
+	Account           *GuildIntegrationAccount `json:"account"`
+	SyncedAt          int                      `json:"synced_at"`
+}
+
+// A GuildIntegrationAccount stores data for a guild integration account.
+type GuildIntegrationAccount struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+}
+
+// A GuildEmbed stores data for a guild embed.
+type GuildEmbed struct {
+	Enabled   bool   `json:"enabled"`
+	ChannelID string `json:"channel_id"`
+}
+
+// A UserGuildSettingsChannelOverride stores data for a channel override for a users guild settings.
+type UserGuildSettingsChannelOverride struct {
+	Muted                bool   `json:"muted"`
+	MessageNotifications int    `json:"message_notifications"`
+	ChannelID            string `json:"channel_id"`
+}
+
+// A UserGuildSettings stores data for a users guild settings.
+type UserGuildSettings struct {
+	SupressEveryone      bool                                `json:"suppress_everyone"`
+	Muted                bool                                `json:"muted"`
+	MobilePush           bool                                `json:"mobile_push"`
+	MessageNotifications int                                 `json:"message_notifications"`
+	GuildID              string                              `json:"guild_id"`
+	ChannelOverrides     []*UserGuildSettingsChannelOverride `json:"channel_overrides"`
+}
+
+// A UserGuildSettingsEdit stores data for editing UserGuildSettings
+type UserGuildSettingsEdit struct {
+	SupressEveryone      bool                                         `json:"suppress_everyone"`
+	Muted                bool                                         `json:"muted"`
+	MobilePush           bool                                         `json:"mobile_push"`
+	MessageNotifications int                                          `json:"message_notifications"`
+	ChannelOverrides     map[string]*UserGuildSettingsChannelOverride `json:"channel_overrides"`
+}
+
+// Constants for the different bit offsets of text channel permissions
+const (
+	PermissionReadMessages = 1 << (iota + 10)
+	PermissionSendMessages
+	PermissionSendTTSMessages
+	PermissionManageMessages
+	PermissionEmbedLinks
+	PermissionAttachFiles
+	PermissionReadMessageHistory
+	PermissionMentionEveryone
+)
+
+// Constants for the different bit offsets of voice permissions
+const (
+	PermissionVoiceConnect = 1 << (iota + 20)
+	PermissionVoiceSpeak
+	PermissionVoiceMuteMembers
+	PermissionVoiceDeafenMembers
+	PermissionVoiceMoveMembers
+	PermissionVoiceUseVAD
+)
+
+// Constants for the different bit offsets of general permissions
+const (
+	PermissionCreateInstantInvite = 1 << iota
+	PermissionKickMembers
+	PermissionBanMembers
+	PermissionManageRoles
+	PermissionManageChannels
+	PermissionManageServer
+
+	PermissionAllText = PermissionReadMessages |
+		PermissionSendMessages |
+		PermissionSendTTSMessages |
+		PermissionManageMessages |
+		PermissionEmbedLinks |
+		PermissionAttachFiles |
+		PermissionReadMessageHistory |
+		PermissionMentionEveryone
+	PermissionAllVoice = PermissionVoiceConnect |
+		PermissionVoiceSpeak |
+		PermissionVoiceMuteMembers |
+		PermissionVoiceDeafenMembers |
+		PermissionVoiceMoveMembers |
+		PermissionVoiceUseVAD
+	PermissionAllChannel = PermissionAllText |
+		PermissionAllVoice |
+		PermissionCreateInstantInvite |
+		PermissionManageRoles |
+		PermissionManageChannels
+	PermissionAll = PermissionAllChannel |
+		PermissionKickMembers |
+		PermissionBanMembers |
+		PermissionManageServer
+)

vendor/github.com/bwmarrin/discordgo/voice.go

@@ -0,0 +1,853 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains code related to Discord voice suppport
+
+package discordgo
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"golang.org/x/crypto/nacl/secretbox"
+)
+
+// ------------------------------------------------------------------------------------------------
+// Code related to both VoiceConnection Websocket and UDP connections.
+// ------------------------------------------------------------------------------------------------
+
+// A VoiceConnection struct holds all the data and functions related to a Discord Voice Connection.
+type VoiceConnection struct {
+	sync.RWMutex
+
+	Debug        bool // If true, print extra logging -- DEPRECATED
+	LogLevel     int
+	Ready        bool // If true, voice is ready to send/receive audio
+	UserID       string
+	GuildID      string
+	ChannelID    string
+	deaf         bool
+	mute         bool
+	speaking     bool
+	reconnecting bool // If true, voice connection is trying to reconnect
+
+	OpusSend chan []byte  // Chan for sending opus audio
+	OpusRecv chan *Packet // Chan for receiving opus audio
+
+	wsConn  *websocket.Conn
+	wsMutex sync.Mutex
+	udpConn *net.UDPConn
+	session *Session
+
+	sessionID string
+	token     string
+	endpoint  string
+
+	// Used to send a close signal to goroutines
+	close chan struct{}
+
+	// Used to allow blocking until connected
+	connected chan bool
+
+	// Used to pass the sessionid from onVoiceStateUpdate
+	// sessionRecv chan string UNUSED ATM
+
+	op4 voiceOP4
+	op2 voiceOP2
+
+	voiceSpeakingUpdateHandlers []VoiceSpeakingUpdateHandler
+}
+
+// VoiceSpeakingUpdateHandler type provides a function defination for the
+// VoiceSpeakingUpdate event
+type VoiceSpeakingUpdateHandler func(vc *VoiceConnection, vs *VoiceSpeakingUpdate)
+
+// Speaking sends a speaking notification to Discord over the voice websocket.
+// This must be sent as true prior to sending audio and should be set to false
+// once finished sending audio.
+//  b  : Send true if speaking, false if not.
+func (v *VoiceConnection) Speaking(b bool) (err error) {
+
+	v.log(LogDebug, "called (%t)", b)
+
+	type voiceSpeakingData struct {
+		Speaking bool `json:"speaking"`
+		Delay    int  `json:"delay"`
+	}
+
+	type voiceSpeakingOp struct {
+		Op   int               `json:"op"` // Always 5
+		Data voiceSpeakingData `json:"d"`
+	}
+
+	if v.wsConn == nil {
+		return fmt.Errorf("No VoiceConnection websocket.")
+	}
+
+	data := voiceSpeakingOp{5, voiceSpeakingData{b, 0}}
+	v.wsMutex.Lock()
+	err = v.wsConn.WriteJSON(data)
+	v.wsMutex.Unlock()
+	if err != nil {
+		v.speaking = false
+		log.Println("Speaking() write json error:", err)
+		return
+	}
+	v.speaking = b
+
+	return
+}
+
+// ChangeChannel sends Discord a request to change channels within a Guild
+// !!! NOTE !!! This function may be removed in favour of just using ChannelVoiceJoin
+func (v *VoiceConnection) ChangeChannel(channelID string, mute, deaf bool) (err error) {
+
+	v.log(LogInformational, "called")
+
+	data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, &channelID, mute, deaf}}
+	v.wsMutex.Lock()
+	err = v.session.wsConn.WriteJSON(data)
+	v.wsMutex.Unlock()
+	if err != nil {
+		return
+	}
+	v.ChannelID = channelID
+	v.deaf = deaf
+	v.mute = mute
+	v.speaking = false
+
+	return
+}
+
+// Disconnect disconnects from this voice channel and closes the websocket
+// and udp connections to Discord.
+// !!! NOTE !!! this function may be removed in favour of ChannelVoiceLeave
+func (v *VoiceConnection) Disconnect() (err error) {
+
+	// Send a OP4 with a nil channel to disconnect
+	if v.sessionID != "" {
+		data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, nil, true, true}}
+		v.wsMutex.Lock()
+		err = v.session.wsConn.WriteJSON(data)
+		v.wsMutex.Unlock()
+		v.sessionID = ""
+	}
+
+	// Close websocket and udp connections
+	v.Close()
+
+	v.log(LogInformational, "Deleting VoiceConnection %s", v.GuildID)
+	delete(v.session.VoiceConnections, v.GuildID)
+
+	return
+}
+
+// Close closes the voice ws and udp connections
+func (v *VoiceConnection) Close() {
+
+	v.log(LogInformational, "called")
+
+	v.Lock()
+	defer v.Unlock()
+
+	v.Ready = false
+	v.speaking = false
+
+	if v.close != nil {
+		v.log(LogInformational, "closing v.close")
+		close(v.close)
+		v.close = nil
+	}
+
+	if v.udpConn != nil {
+		v.log(LogInformational, "closing udp")
+		err := v.udpConn.Close()
+		if err != nil {
+			log.Println("error closing udp connection: ", err)
+		}
+		v.udpConn = nil
+	}
+
+	if v.wsConn != nil {
+		v.log(LogInformational, "sending close frame")
+
+		// To cleanly close a connection, a client should send a close
+		// frame and wait for the server to close the connection.
+		err := v.wsConn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+		if err != nil {
+			v.log(LogError, "error closing websocket, %s", err)
+		}
+
+		// TODO: Wait for Discord to actually close the connection.
+		time.Sleep(1 * time.Second)
+
+		v.log(LogInformational, "closing websocket")
+		err = v.wsConn.Close()
+		if err != nil {
+			v.log(LogError, "error closing websocket, %s", err)
+		}
+
+		v.wsConn = nil
+	}
+}
+
+// AddHandler adds a Handler for VoiceSpeakingUpdate events.
+func (v *VoiceConnection) AddHandler(h VoiceSpeakingUpdateHandler) {
+	v.Lock()
+	defer v.Unlock()
+
+	v.voiceSpeakingUpdateHandlers = append(v.voiceSpeakingUpdateHandlers, h)
+}
+
+// VoiceSpeakingUpdate is a struct for a VoiceSpeakingUpdate event.
+type VoiceSpeakingUpdate struct {
+	UserID   string `json:"user_id"`
+	SSRC     int    `json:"ssrc"`
+	Speaking bool   `json:"speaking"`
+}
+
+// ------------------------------------------------------------------------------------------------
+// Unexported Internal Functions Below.
+// ------------------------------------------------------------------------------------------------
+
+// A voiceOP4 stores the data for the voice operation 4 websocket event
+// which provides us with the NaCl SecretBox encryption key
+type voiceOP4 struct {
+	SecretKey [32]byte `json:"secret_key"`
+	Mode      string   `json:"mode"`
+}
+
+// A voiceOP2 stores the data for the voice operation 2 websocket event
+// which is sort of like the voice READY packet
+type voiceOP2 struct {
+	SSRC              uint32        `json:"ssrc"`
+	Port              int           `json:"port"`
+	Modes             []string      `json:"modes"`
+	HeartbeatInterval time.Duration `json:"heartbeat_interval"`
+}
+
+// WaitUntilConnected waits for the Voice Connection to
+// become ready, if it does not become ready it retuns an err
+func (v *VoiceConnection) waitUntilConnected() error {
+
+	v.log(LogInformational, "called")
+
+	i := 0
+	for {
+		if v.Ready {
+			return nil
+		}
+
+		if i > 10 {
+			return fmt.Errorf("Timeout waiting for voice.")
+		}
+
+		time.Sleep(1 * time.Second)
+		i++
+	}
+}
+
+// Open opens a voice connection.  This should be called
+// after VoiceChannelJoin is used and the data VOICE websocket events
+// are captured.
+func (v *VoiceConnection) open() (err error) {
+
+	v.log(LogInformational, "called")
+
+	v.Lock()
+	defer v.Unlock()
+
+	// Don't open a websocket if one is already open
+	if v.wsConn != nil {
+		v.log(LogWarning, "refusing to overwrite non-nil websocket")
+		return
+	}
+
+	// TODO temp? loop to wait for the SessionID
+	i := 0
+	for {
+		if v.sessionID != "" {
+			break
+		}
+		if i > 20 { // only loop for up to 1 second total
+			return fmt.Errorf("Did not receive voice Session ID in time.")
+		}
+		time.Sleep(50 * time.Millisecond)
+		i++
+	}
+
+	// Connect to VoiceConnection Websocket
+	vg := fmt.Sprintf("wss://%s", strings.TrimSuffix(v.endpoint, ":80"))
+	v.log(LogInformational, "connecting to voice endpoint %s", vg)
+	v.wsConn, _, err = websocket.DefaultDialer.Dial(vg, nil)
+	if err != nil {
+		v.log(LogWarning, "error connecting to voice endpoint %s, %s", vg, err)
+		v.log(LogDebug, "voice struct: %#v\n", v)
+		return
+	}
+
+	type voiceHandshakeData struct {
+		ServerID  string `json:"server_id"`
+		UserID    string `json:"user_id"`
+		SessionID string `json:"session_id"`
+		Token     string `json:"token"`
+	}
+	type voiceHandshakeOp struct {
+		Op   int                `json:"op"` // Always 0
+		Data voiceHandshakeData `json:"d"`
+	}
+	data := voiceHandshakeOp{0, voiceHandshakeData{v.GuildID, v.UserID, v.sessionID, v.token}}
+
+	err = v.wsConn.WriteJSON(data)
+	if err != nil {
+		v.log(LogWarning, "error sending init packet, %s", err)
+		return
+	}
+
+	v.close = make(chan struct{})
+	go v.wsListen(v.wsConn, v.close)
+
+	// add loop/check for Ready bool here?
+	// then return false if not ready?
+	// but then wsListen will also err.
+
+	return
+}
+
+// wsListen listens on the voice websocket for messages and passes them
+// to the voice event handler.  This is automatically called by the Open func
+func (v *VoiceConnection) wsListen(wsConn *websocket.Conn, close <-chan struct{}) {
+
+	v.log(LogInformational, "called")
+
+	for {
+		_, message, err := v.wsConn.ReadMessage()
+		if err != nil {
+			// Detect if we have been closed manually. If a Close() has already
+			// happened, the websocket we are listening on will be different to the
+			// current session.
+			v.RLock()
+			sameConnection := v.wsConn == wsConn
+			v.RUnlock()
+			if sameConnection {
+
+				v.log(LogError, "voice endpoint %s websocket closed unexpectantly, %s", v.endpoint, err)
+
+				// Start reconnect goroutine then exit.
+				go v.reconnect()
+			}
+			return
+		}
+
+		// Pass received message to voice event handler
+		select {
+		case <-close:
+			return
+		default:
+			go v.onEvent(message)
+		}
+	}
+}
+
+// wsEvent handles any voice websocket events. This is only called by the
+// wsListen() function.
+func (v *VoiceConnection) onEvent(message []byte) {
+
+	v.log(LogDebug, "received: %s", string(message))
+
+	var e Event
+	if err := json.Unmarshal(message, &e); err != nil {
+		v.log(LogError, "unmarshall error, %s", err)
+		return
+	}
+
+	switch e.Operation {
+
+	case 2: // READY
+
+		if err := json.Unmarshal(e.RawData, &v.op2); err != nil {
+			v.log(LogError, "OP2 unmarshall error, %s, %s", err, string(e.RawData))
+			return
+		}
+
+		// Start the voice websocket heartbeat to keep the connection alive
+		go v.wsHeartbeat(v.wsConn, v.close, v.op2.HeartbeatInterval)
+		// TODO monitor a chan/bool to verify this was successful
+
+		// Start the UDP connection
+		err := v.udpOpen()
+		if err != nil {
+			v.log(LogError, "error opening udp connection, %s", err)
+			return
+		}
+
+		// Start the opusSender.
+		// TODO: Should we allow 48000/960 values to be user defined?
+		if v.OpusSend == nil {
+			v.OpusSend = make(chan []byte, 2)
+		}
+		go v.opusSender(v.udpConn, v.close, v.OpusSend, 48000, 960)
+
+		// Start the opusReceiver
+		if !v.deaf {
+			if v.OpusRecv == nil {
+				v.OpusRecv = make(chan *Packet, 2)
+			}
+
+			go v.opusReceiver(v.udpConn, v.close, v.OpusRecv)
+		}
+
+		// Send the ready event
+		v.connected <- true
+		return
+
+	case 3: // HEARTBEAT response
+		// add code to use this to track latency?
+		return
+
+	case 4: // udp encryption secret key
+		v.op4 = voiceOP4{}
+		if err := json.Unmarshal(e.RawData, &v.op4); err != nil {
+			v.log(LogError, "OP4 unmarshall error, %s, %s", err, string(e.RawData))
+			return
+		}
+		return
+
+	case 5:
+		if len(v.voiceSpeakingUpdateHandlers) == 0 {
+			return
+		}
+
+		voiceSpeakingUpdate := &VoiceSpeakingUpdate{}
+		if err := json.Unmarshal(e.RawData, voiceSpeakingUpdate); err != nil {
+			v.log(LogError, "OP5 unmarshall error, %s, %s", err, string(e.RawData))
+			return
+		}
+
+		for _, h := range v.voiceSpeakingUpdateHandlers {
+			h(v, voiceSpeakingUpdate)
+		}
+
+	default:
+		v.log(LogError, "unknown voice operation, %d, %s", e.Operation, string(e.RawData))
+	}
+
+	return
+}
+
+type voiceHeartbeatOp struct {
+	Op   int `json:"op"` // Always 3
+	Data int `json:"d"`
+}
+
+// NOTE :: When a guild voice server changes how do we shut this down
+// properly, so a new connection can be setup without fuss?
+//
+// wsHeartbeat sends regular heartbeats to voice Discord so it knows the client
+// is still connected.  If you do not send these heartbeats Discord will
+// disconnect the websocket connection after a few seconds.
+func (v *VoiceConnection) wsHeartbeat(wsConn *websocket.Conn, close <-chan struct{}, i time.Duration) {
+
+	if close == nil || wsConn == nil {
+		return
+	}
+
+	var err error
+	ticker := time.NewTicker(i * time.Millisecond)
+	for {
+		v.log(LogDebug, "sending heartbeat packet")
+		v.wsMutex.Lock()
+		err = wsConn.WriteJSON(voiceHeartbeatOp{3, int(time.Now().Unix())})
+		v.wsMutex.Unlock()
+		if err != nil {
+			v.log(LogError, "error sending heartbeat to voice endpoint %s, %s", v.endpoint, err)
+			return
+		}
+
+		select {
+		case <-ticker.C:
+			// continue loop and send heartbeat
+		case <-close:
+			return
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Code related to the VoiceConnection UDP connection
+// ------------------------------------------------------------------------------------------------
+
+type voiceUDPData struct {
+	Address string `json:"address"` // Public IP of machine running this code
+	Port    uint16 `json:"port"`    // UDP Port of machine running this code
+	Mode    string `json:"mode"`    // always "xsalsa20_poly1305"
+}
+
+type voiceUDPD struct {
+	Protocol string       `json:"protocol"` // Always "udp" ?
+	Data     voiceUDPData `json:"data"`
+}
+
+type voiceUDPOp struct {
+	Op   int       `json:"op"` // Always 1
+	Data voiceUDPD `json:"d"`
+}
+
+// udpOpen opens a UDP connection to the voice server and completes the
+// initial required handshake.  This connection is left open in the session
+// and can be used to send or receive audio.  This should only be called
+// from voice.wsEvent OP2
+func (v *VoiceConnection) udpOpen() (err error) {
+
+	v.Lock()
+	defer v.Unlock()
+
+	if v.wsConn == nil {
+		return fmt.Errorf("nil voice websocket")
+	}
+
+	if v.udpConn != nil {
+		return fmt.Errorf("udp connection already open")
+	}
+
+	if v.close == nil {
+		return fmt.Errorf("nil close channel")
+	}
+
+	if v.endpoint == "" {
+		return fmt.Errorf("empty endpoint")
+	}
+
+	host := fmt.Sprintf("%s:%d", strings.TrimSuffix(v.endpoint, ":80"), v.op2.Port)
+	addr, err := net.ResolveUDPAddr("udp", host)
+	if err != nil {
+		v.log(LogWarning, "error resolving udp host %s, %s", host, err)
+		return
+	}
+
+	v.log(LogInformational, "connecting to udp addr %s", addr.String())
+	v.udpConn, err = net.DialUDP("udp", nil, addr)
+	if err != nil {
+		v.log(LogWarning, "error connecting to udp addr %s, %s", addr.String(), err)
+		return
+	}
+
+	// Create a 70 byte array and put the SSRC code from the Op 2 VoiceConnection event
+	// into it.  Then send that over the UDP connection to Discord
+	sb := make([]byte, 70)
+	binary.BigEndian.PutUint32(sb, v.op2.SSRC)
+	_, err = v.udpConn.Write(sb)
+	if err != nil {
+		v.log(LogWarning, "udp write error to %s, %s", addr.String(), err)
+		return
+	}
+
+	// Create a 70 byte array and listen for the initial handshake response
+	// from Discord.  Once we get it parse the IP and PORT information out
+	// of the response.  This should be our public IP and PORT as Discord
+	// saw us.
+	rb := make([]byte, 70)
+	rlen, _, err := v.udpConn.ReadFromUDP(rb)
+	if err != nil {
+		v.log(LogWarning, "udp read error, %s, %s", addr.String(), err)
+		return
+	}
+
+	if rlen < 70 {
+		v.log(LogWarning, "received udp packet too small")
+		return fmt.Errorf("received udp packet too small")
+	}
+
+	// Loop over position 4 though 20 to grab the IP address
+	// Should never be beyond position 20.
+	var ip string
+	for i := 4; i < 20; i++ {
+		if rb[i] == 0 {
+			break
+		}
+		ip += string(rb[i])
+	}
+
+	// Grab port from position 68 and 69
+	port := binary.LittleEndian.Uint16(rb[68:70])
+
+	// Take the data from above and send it back to Discord to finalize
+	// the UDP connection handshake.
+	data := voiceUDPOp{1, voiceUDPD{"udp", voiceUDPData{ip, port, "xsalsa20_poly1305"}}}
+
+	v.wsMutex.Lock()
+	err = v.wsConn.WriteJSON(data)
+	v.wsMutex.Unlock()
+	if err != nil {
+		v.log(LogWarning, "udp write error, %#v, %s", data, err)
+		return
+	}
+
+	// start udpKeepAlive
+	go v.udpKeepAlive(v.udpConn, v.close, 5*time.Second)
+	// TODO: find a way to check that it fired off okay
+
+	return
+}
+
+// udpKeepAlive sends a udp packet to keep the udp connection open
+// This is still a bit of a "proof of concept"
+func (v *VoiceConnection) udpKeepAlive(udpConn *net.UDPConn, close <-chan struct{}, i time.Duration) {
+
+	if udpConn == nil || close == nil {
+		return
+	}
+
+	var err error
+	var sequence uint64
+
+	packet := make([]byte, 8)
+
+	ticker := time.NewTicker(i)
+	for {
+
+		binary.LittleEndian.PutUint64(packet, sequence)
+		sequence++
+
+		_, err = udpConn.Write(packet)
+		if err != nil {
+			v.log(LogError, "write error, %s", err)
+			return
+		}
+
+		select {
+		case <-ticker.C:
+			// continue loop and send keepalive
+		case <-close:
+			return
+		}
+	}
+}
+
+// opusSender will listen on the given channel and send any
+// pre-encoded opus audio to Discord.  Supposedly.
+func (v *VoiceConnection) opusSender(udpConn *net.UDPConn, close <-chan struct{}, opus <-chan []byte, rate, size int) {
+
+	if udpConn == nil || close == nil {
+		return
+	}
+
+	runtime.LockOSThread()
+
+	// VoiceConnection is now ready to receive audio packets
+	// TODO: this needs reviewed as I think there must be a better way.
+	v.Ready = true
+	defer func() { v.Ready = false }()
+
+	var sequence uint16
+	var timestamp uint32
+	var recvbuf []byte
+	var ok bool
+	udpHeader := make([]byte, 12)
+	var nonce [24]byte
+
+	// build the parts that don't change in the udpHeader
+	udpHeader[0] = 0x80
+	udpHeader[1] = 0x78
+	binary.BigEndian.PutUint32(udpHeader[8:], v.op2.SSRC)
+
+	// start a send loop that loops until buf chan is closed
+	ticker := time.NewTicker(time.Millisecond * time.Duration(size/(rate/1000)))
+	for {
+
+		// Get data from chan.  If chan is closed, return.
+		select {
+		case <-close:
+			return
+		case recvbuf, ok = <-opus:
+			if !ok {
+				return
+			}
+			// else, continue loop
+		}
+
+		if !v.speaking {
+			err := v.Speaking(true)
+			if err != nil {
+				v.log(LogError, "error sending speaking packet, %s", err)
+			}
+		}
+
+		// Add sequence and timestamp to udpPacket
+		binary.BigEndian.PutUint16(udpHeader[2:], sequence)
+		binary.BigEndian.PutUint32(udpHeader[4:], timestamp)
+
+		// encrypt the opus data
+		copy(nonce[:], udpHeader)
+		sendbuf := secretbox.Seal(udpHeader, recvbuf, &nonce, &v.op4.SecretKey)
+
+		// block here until we're exactly at the right time :)
+		// Then send rtp audio packet to Discord over UDP
+		select {
+		case <-close:
+			return
+		case <-ticker.C:
+			// continue
+		}
+		_, err := udpConn.Write(sendbuf)
+
+		if err != nil {
+			v.log(LogError, "udp write error, %s", err)
+			v.log(LogDebug, "voice struct: %#v\n", v)
+			return
+		}
+
+		if (sequence) == 0xFFFF {
+			sequence = 0
+		} else {
+			sequence++
+		}
+
+		if (timestamp + uint32(size)) >= 0xFFFFFFFF {
+			timestamp = 0
+		} else {
+			timestamp += uint32(size)
+		}
+	}
+}
+
+// A Packet contains the headers and content of a received voice packet.
+type Packet struct {
+	SSRC      uint32
+	Sequence  uint16
+	Timestamp uint32
+	Type      []byte
+	Opus      []byte
+	PCM       []int16
+}
+
+// opusReceiver listens on the UDP socket for incoming packets
+// and sends them across the given channel
+// NOTE :: This function may change names later.
+func (v *VoiceConnection) opusReceiver(udpConn *net.UDPConn, close <-chan struct{}, c chan *Packet) {
+
+	if udpConn == nil || close == nil {
+		return
+	}
+
+	p := Packet{}
+	recvbuf := make([]byte, 1024)
+	var nonce [24]byte
+
+	for {
+		rlen, err := udpConn.Read(recvbuf)
+		if err != nil {
+			// Detect if we have been closed manually. If a Close() has already
+			// happened, the udp connection we are listening on will be different
+			// to the current session.
+			v.RLock()
+			sameConnection := v.udpConn == udpConn
+			v.RUnlock()
+			if sameConnection {
+
+				v.log(LogError, "udp read error, %s, %s", v.endpoint, err)
+				v.log(LogDebug, "voice struct: %#v\n", v)
+
+				go v.reconnect()
+			}
+			return
+		}
+
+		select {
+		case <-close:
+			return
+		default:
+			// continue loop
+		}
+
+		// For now, skip anything except audio.
+		if rlen < 12 || recvbuf[0] != 0x80 {
+			continue
+		}
+
+		// build a audio packet struct
+		p.Type = recvbuf[0:2]
+		p.Sequence = binary.BigEndian.Uint16(recvbuf[2:4])
+		p.Timestamp = binary.BigEndian.Uint32(recvbuf[4:8])
+		p.SSRC = binary.BigEndian.Uint32(recvbuf[8:12])
+		// decrypt opus data
+		copy(nonce[:], recvbuf[0:12])
+		p.Opus, _ = secretbox.Open(nil, recvbuf[12:rlen], &nonce, &v.op4.SecretKey)
+
+		if c != nil {
+			c <- &p
+		}
+	}
+}
+
+// Reconnect will close down a voice connection then immediately try to
+// reconnect to that session.
+// NOTE : This func is messy and a WIP while I find what works.
+// It will be cleaned up once a proven stable option is flushed out.
+// aka: this is ugly shit code, please don't judge too harshly.
+func (v *VoiceConnection) reconnect() {
+
+	v.log(LogInformational, "called")
+
+	v.Lock()
+	if v.reconnecting {
+		v.log(LogInformational, "already reconnecting to channel %s, exiting", v.ChannelID)
+		v.Unlock()
+		return
+	}
+	v.reconnecting = true
+	v.Unlock()
+
+	defer func() { v.reconnecting = false }()
+
+	// Close any currently open connections
+	v.Close()
+
+	wait := time.Duration(1)
+	for {
+
+		<-time.After(wait * time.Second)
+		wait *= 2
+		if wait > 600 {
+			wait = 600
+		}
+
+		if v.session.DataReady == false || v.session.wsConn == nil {
+			v.log(LogInformational, "cannot reconenct to channel %s with unready session", v.ChannelID)
+			continue
+		}
+
+		v.log(LogInformational, "trying to reconnect to channel %s", v.ChannelID)
+
+		_, err := v.session.ChannelVoiceJoin(v.GuildID, v.ChannelID, v.mute, v.deaf)
+		if err == nil {
+			v.log(LogInformational, "successfully reconnected to channel %s", v.ChannelID)
+			return
+		}
+
+		// if the reconnect above didn't work lets just send a disconnect
+		// packet to reset things.
+		// Send a OP4 with a nil channel to disconnect
+		data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, nil, true, true}}
+		v.session.wsMutex.Lock()
+		err = v.session.wsConn.WriteJSON(data)
+		v.session.wsMutex.Unlock()
+		if err != nil {
+			v.log(LogError, "error sending disconnect packet, %s", err)
+		}
+
+		v.log(LogInformational, "error reconnecting to channel %s, %s", v.ChannelID, err)
+	}
+}

vendor/github.com/bwmarrin/discordgo/wsapi.go

@@ -0,0 +1,679 @@
+// Discordgo - Discord bindings for Go
+// Available at https://github.com/bwmarrin/discordgo
+
+// Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains low level functions for interacting with the Discord
+// data websocket interface.
+
+package discordgo
+
+import (
+	"bytes"
+	"compress/zlib"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"reflect"
+	"runtime"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type resumePacket struct {
+	Op   int `json:"op"`
+	Data struct {
+		Token     string `json:"token"`
+		SessionID string `json:"session_id"`
+		Sequence  int    `json:"seq"`
+	} `json:"d"`
+}
+
+// Open opens a websocket connection to Discord.
+func (s *Session) Open() (err error) {
+
+	s.log(LogInformational, "called")
+
+	s.Lock()
+	defer func() {
+		if err != nil {
+			s.Unlock()
+		}
+	}()
+
+	if s.wsConn != nil {
+		err = errors.New("Web socket already opened.")
+		return
+	}
+
+	if s.VoiceConnections == nil {
+		s.log(LogInformational, "creating new VoiceConnections map")
+		s.VoiceConnections = make(map[string]*VoiceConnection)
+	}
+
+	// Get the gateway to use for the Websocket connection
+	if s.gateway == "" {
+		s.gateway, err = s.Gateway()
+		if err != nil {
+			return
+		}
+
+		// Add the version and encoding to the URL
+		s.gateway = fmt.Sprintf("%s?v=4&encoding=json", s.gateway)
+	}
+
+	header := http.Header{}
+	header.Add("accept-encoding", "zlib")
+
+	s.log(LogInformational, "connecting to gateway %s", s.gateway)
+	s.wsConn, _, err = websocket.DefaultDialer.Dial(s.gateway, header)
+	if err != nil {
+		s.log(LogWarning, "error connecting to gateway %s, %s", s.gateway, err)
+		s.gateway = "" // clear cached gateway
+		// TODO: should we add a retry block here?
+		return
+	}
+
+	if s.sessionID != "" && s.sequence > 0 {
+
+		p := resumePacket{}
+		p.Op = 6
+		p.Data.Token = s.Token
+		p.Data.SessionID = s.sessionID
+		p.Data.Sequence = s.sequence
+
+		s.log(LogInformational, "sending resume packet to gateway")
+		err = s.wsConn.WriteJSON(p)
+		if err != nil {
+			s.log(LogWarning, "error sending gateway resume packet, %s, %s", s.gateway, err)
+			return
+		}
+
+	} else {
+
+		err = s.identify()
+		if err != nil {
+			s.log(LogWarning, "error sending gateway identify packet, %s, %s", s.gateway, err)
+			return
+		}
+	}
+
+	// Create listening outside of listen, as it needs to happen inside the mutex
+	// lock.
+	s.listening = make(chan interface{})
+	go s.listen(s.wsConn, s.listening)
+
+	s.Unlock()
+
+	s.initialize()
+	s.log(LogInformational, "emit connect event")
+	s.handle(&Connect{})
+
+	s.log(LogInformational, "exiting")
+	return
+}
+
+// listen polls the websocket connection for events, it will stop when the
+// listening channel is closed, or an error occurs.
+func (s *Session) listen(wsConn *websocket.Conn, listening <-chan interface{}) {
+
+	s.log(LogInformational, "called")
+
+	for {
+
+		messageType, message, err := wsConn.ReadMessage()
+
+		if err != nil {
+
+			// Detect if we have been closed manually. If a Close() has already
+			// happened, the websocket we are listening on will be different to
+			// the current session.
+			s.RLock()
+			sameConnection := s.wsConn == wsConn
+			s.RUnlock()
+
+			if sameConnection {
+
+				s.log(LogWarning, "error reading from gateway %s websocket, %s", s.gateway, err)
+				// There has been an error reading, close the websocket so that
+				// OnDisconnect event is emitted.
+				err := s.Close()
+				if err != nil {
+					s.log(LogWarning, "error closing session connection, %s", err)
+				}
+
+				s.log(LogInformational, "calling reconnect() now")
+				s.reconnect()
+			}
+
+			return
+		}
+
+		select {
+
+		case <-listening:
+			return
+
+		default:
+			s.onEvent(messageType, message)
+
+		}
+	}
+}
+
+type heartbeatOp struct {
+	Op   int `json:"op"`
+	Data int `json:"d"`
+}
+
+// heartbeat sends regular heartbeats to Discord so it knows the client
+// is still connected.  If you do not send these heartbeats Discord will
+// disconnect the websocket connection after a few seconds.
+func (s *Session) heartbeat(wsConn *websocket.Conn, listening <-chan interface{}, i time.Duration) {
+
+	s.log(LogInformational, "called")
+
+	if listening == nil || wsConn == nil {
+		return
+	}
+
+	var err error
+	ticker := time.NewTicker(i * time.Millisecond)
+
+	for {
+
+		s.log(LogInformational, "sending gateway websocket heartbeat seq %d", s.sequence)
+		s.wsMutex.Lock()
+		err = wsConn.WriteJSON(heartbeatOp{1, s.sequence})
+		s.wsMutex.Unlock()
+		if err != nil {
+			s.log(LogError, "error sending heartbeat to gateway %s, %s", s.gateway, err)
+			s.Lock()
+			s.DataReady = false
+			s.Unlock()
+			return
+		}
+		s.Lock()
+		s.DataReady = true
+		s.Unlock()
+
+		select {
+		case <-ticker.C:
+			// continue loop and send heartbeat
+		case <-listening:
+			return
+		}
+	}
+}
+
+type updateStatusData struct {
+	IdleSince *int  `json:"idle_since"`
+	Game      *Game `json:"game"`
+}
+
+type updateStatusOp struct {
+	Op   int              `json:"op"`
+	Data updateStatusData `json:"d"`
+}
+
+// UpdateStreamingStatus is used to update the user's streaming status.
+// If idle>0 then set status to idle.
+// If game!="" then set game.
+// If game!="" and url!="" then set the status type to streaming with the URL set.
+// if otherwise, set status to active, and no game.
+func (s *Session) UpdateStreamingStatus(idle int, game string, url string) (err error) {
+
+	s.log(LogInformational, "called")
+
+	s.RLock()
+	defer s.RUnlock()
+	if s.wsConn == nil {
+		return errors.New("no websocket connection exists")
+	}
+
+	var usd updateStatusData
+	if idle > 0 {
+		usd.IdleSince = &idle
+	}
+
+	if game != "" {
+		gameType := 0
+		if url != "" {
+			gameType = 1
+		}
+		usd.Game = &Game{
+			Name: game,
+			Type: gameType,
+			URL:  url,
+		}
+	}
+
+	s.wsMutex.Lock()
+	err = s.wsConn.WriteJSON(updateStatusOp{3, usd})
+	s.wsMutex.Unlock()
+
+	return
+}
+
+// UpdateStatus is used to update the user's status.
+// If idle>0 then set status to idle.
+// If game!="" then set game.
+// if otherwise, set status to active, and no game.
+func (s *Session) UpdateStatus(idle int, game string) (err error) {
+	return s.UpdateStreamingStatus(idle, game, "")
+}
+
+// onEvent is the "event handler" for all messages received on the
+// Discord Gateway API websocket connection.
+//
+// If you use the AddHandler() function to register a handler for a
+// specific event this function will pass the event along to that handler.
+//
+// If you use the AddHandler() function to register a handler for the
+// "OnEvent" event then all events will be passed to that handler.
+//
+// TODO: You may also register a custom event handler entirely using...
+func (s *Session) onEvent(messageType int, message []byte) {
+
+	var err error
+	var reader io.Reader
+	reader = bytes.NewBuffer(message)
+
+	// If this is a compressed message, uncompress it.
+	if messageType == websocket.BinaryMessage {
+
+		z, err2 := zlib.NewReader(reader)
+		if err2 != nil {
+			s.log(LogError, "error uncompressing websocket message, %s", err)
+			return
+		}
+
+		defer func() {
+			err3 := z.Close()
+			if err3 != nil {
+				s.log(LogWarning, "error closing zlib, %s", err)
+			}
+		}()
+
+		reader = z
+	}
+
+	// Decode the event into an Event struct.
+	var e *Event
+	decoder := json.NewDecoder(reader)
+	if err = decoder.Decode(&e); err != nil {
+		s.log(LogError, "error decoding websocket message, %s", err)
+		return
+	}
+
+	s.log(LogDebug, "Op: %d, Seq: %d, Type: %s, Data: %s\n\n", e.Operation, e.Sequence, e.Type, string(e.RawData))
+
+	// Ping request.
+	// Must respond with a heartbeat packet within 5 seconds
+	if e.Operation == 1 {
+		s.log(LogInformational, "sending heartbeat in response to Op1")
+		s.wsMutex.Lock()
+		err = s.wsConn.WriteJSON(heartbeatOp{1, s.sequence})
+		s.wsMutex.Unlock()
+		if err != nil {
+			s.log(LogError, "error sending heartbeat in response to Op1")
+			return
+		}
+
+		return
+	}
+
+	// Reconnect
+	// Must immediately disconnect from gateway and reconnect to new gateway.
+	if e.Operation == 7 {
+		// TODO
+	}
+
+	// Invalid Session
+	// Must respond with a Identify packet.
+	if e.Operation == 9 {
+
+		s.log(LogInformational, "sending identify packet to gateway in response to Op9")
+
+		err = s.identify()
+		if err != nil {
+			s.log(LogWarning, "error sending gateway identify packet, %s, %s", s.gateway, err)
+			return
+		}
+
+		return
+	}
+
+	// Do not try to Dispatch a non-Dispatch Message
+	if e.Operation != 0 {
+		// But we probably should be doing something with them.
+		// TEMP
+		s.log(LogWarning, "unknown Op: %d, Seq: %d, Type: %s, Data: %s, message: %s", e.Operation, e.Sequence, e.Type, string(e.RawData), string(message))
+		return
+	}
+
+	// Store the message sequence
+	s.sequence = e.Sequence
+
+	// Map event to registered event handlers and pass it along
+	// to any registered functions
+	i := eventToInterface[e.Type]
+	if i != nil {
+
+		// Create a new instance of the event type.
+		i = reflect.New(reflect.TypeOf(i)).Interface()
+
+		// Attempt to unmarshal our event.
+		if err = json.Unmarshal(e.RawData, i); err != nil {
+			s.log(LogError, "error unmarshalling %s event, %s", e.Type, err)
+		}
+
+		// Send event to any registered event handlers for it's type.
+		// Because the above doesn't cancel this, in case of an error
+		// the struct could be partially populated or at default values.
+		// However, most errors are due to a single field and I feel
+		// it's better to pass along what we received than nothing at all.
+		// TODO: Think about that decision :)
+		// Either way, READY events must fire, even with errors.
+		go s.handle(i)
+
+	} else {
+		s.log(LogWarning, "unknown event: Op: %d, Seq: %d, Type: %s, Data: %s", e.Operation, e.Sequence, e.Type, string(e.RawData))
+	}
+
+	// Emit event to the OnEvent handler
+	e.Struct = i
+	go s.handle(e)
+}
+
+// ------------------------------------------------------------------------------------------------
+// Code related to voice connections that initiate over the data websocket
+// ------------------------------------------------------------------------------------------------
+
+// A VoiceServerUpdate stores the data received during the Voice Server Update
+// data websocket event. This data is used during the initial Voice Channel
+// join handshaking.
+type VoiceServerUpdate struct {
+	Token    string `json:"token"`
+	GuildID  string `json:"guild_id"`
+	Endpoint string `json:"endpoint"`
+}
+
+type voiceChannelJoinData struct {
+	GuildID   *string `json:"guild_id"`
+	ChannelID *string `json:"channel_id"`
+	SelfMute  bool    `json:"self_mute"`
+	SelfDeaf  bool    `json:"self_deaf"`
+}
+
+type voiceChannelJoinOp struct {
+	Op   int                  `json:"op"`
+	Data voiceChannelJoinData `json:"d"`
+}
+
+// ChannelVoiceJoin joins the session user to a voice channel.
+//
+//    gID     : Guild ID of the channel to join.
+//    cID     : Channel ID of the channel to join.
+//    mute    : If true, you will be set to muted upon joining.
+//    deaf    : If true, you will be set to deafened upon joining.
+func (s *Session) ChannelVoiceJoin(gID, cID string, mute, deaf bool) (voice *VoiceConnection, err error) {
+
+	s.log(LogInformational, "called")
+
+	voice, _ = s.VoiceConnections[gID]
+
+	if voice == nil {
+		voice = &VoiceConnection{}
+		s.VoiceConnections[gID] = voice
+	}
+
+	voice.GuildID = gID
+	voice.ChannelID = cID
+	voice.deaf = deaf
+	voice.mute = mute
+	voice.session = s
+
+	// Send the request to Discord that we want to join the voice channel
+	data := voiceChannelJoinOp{4, voiceChannelJoinData{&gID, &cID, mute, deaf}}
+	s.wsMutex.Lock()
+	err = s.wsConn.WriteJSON(data)
+	s.wsMutex.Unlock()
+	if err != nil {
+		return
+	}
+
+	// doesn't exactly work perfect yet.. TODO
+	err = voice.waitUntilConnected()
+	if err != nil {
+		s.log(LogWarning, "error waiting for voice to connect, %s", err)
+		voice.Close()
+		return
+	}
+
+	return
+}
+
+// onVoiceStateUpdate handles Voice State Update events on the data websocket.
+func (s *Session) onVoiceStateUpdate(se *Session, st *VoiceStateUpdate) {
+
+	// If we don't have a connection for the channel, don't bother
+	if st.ChannelID == "" {
+		return
+	}
+
+	// Check if we have a voice connection to update
+	voice, exists := s.VoiceConnections[st.GuildID]
+	if !exists {
+		return
+	}
+
+	// Need to have this happen at login and store it in the Session
+	// TODO : This should be done upon connecting to Discord, or
+	// be moved to a small helper function
+	self, err := s.User("@me") // TODO: move to Login/New
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// We only care about events that are about us
+	if st.UserID != self.ID {
+		return
+	}
+
+	// Store the SessionID for later use.
+	voice.UserID = self.ID // TODO: Review
+	voice.sessionID = st.SessionID
+}
+
+// onVoiceServerUpdate handles the Voice Server Update data websocket event.
+//
+// This is also fired if the Guild's voice region changes while connected
+// to a voice channel.  In that case, need to re-establish connection to
+// the new region endpoint.
+func (s *Session) onVoiceServerUpdate(se *Session, st *VoiceServerUpdate) {
+
+	s.log(LogInformational, "called")
+
+	voice, exists := s.VoiceConnections[st.GuildID]
+
+	// If no VoiceConnection exists, just skip this
+	if !exists {
+		return
+	}
+
+	// If currently connected to voice ws/udp, then disconnect.
+	// Has no effect if not connected.
+	voice.Close()
+
+	// Store values for later use
+	voice.token = st.Token
+	voice.endpoint = st.Endpoint
+	voice.GuildID = st.GuildID
+
+	// Open a conenction to the voice server
+	err := voice.open()
+	if err != nil {
+		s.log(LogError, "onVoiceServerUpdate voice.open, %s", err)
+	}
+}
+
+type identifyProperties struct {
+	OS              string `json:"$os"`
+	Browser         string `json:"$browser"`
+	Device          string `json:"$device"`
+	Referer         string `json:"$referer"`
+	ReferringDomain string `json:"$referring_domain"`
+}
+
+type identifyData struct {
+	Token          string             `json:"token"`
+	Properties     identifyProperties `json:"properties"`
+	LargeThreshold int                `json:"large_threshold"`
+	Compress       bool               `json:"compress"`
+	Shard          *[2]int            `json:"shard,omitempty"`
+}
+
+type identifyOp struct {
+	Op   int          `json:"op"`
+	Data identifyData `json:"d"`
+}
+
+// identify sends the identify packet to the gateway
+func (s *Session) identify() error {
+
+	properties := identifyProperties{runtime.GOOS,
+		"Discordgo v" + VERSION,
+		"",
+		"",
+		"",
+	}
+
+	data := identifyData{s.Token,
+		properties,
+		250,
+		s.Compress,
+		nil,
+	}
+
+	if s.ShardCount > 1 {
+
+		if s.ShardID >= s.ShardCount {
+			return errors.New("ShardID must be less than ShardCount")
+		}
+
+		data.Shard = &[2]int{s.ShardID, s.ShardCount}
+	}
+
+	op := identifyOp{2, data}
+
+	s.wsMutex.Lock()
+	err := s.wsConn.WriteJSON(op)
+	s.wsMutex.Unlock()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Session) reconnect() {
+
+	s.log(LogInformational, "called")
+
+	var err error
+
+	if s.ShouldReconnectOnError {
+
+		wait := time.Duration(1)
+
+		for {
+			s.log(LogInformational, "trying to reconnect to gateway")
+
+			err = s.Open()
+			if err == nil {
+				s.log(LogInformational, "successfully reconnected to gateway")
+
+				// I'm not sure if this is actually needed.
+				// if the gw reconnect works properly, voice should stay alive
+				// However, there seems to be cases where something "weird"
+				// happens.  So we're doing this for now just to improve
+				// stability in those edge cases.
+				for _, v := range s.VoiceConnections {
+
+					s.log(LogInformational, "reconnecting voice connection to guild %s", v.GuildID)
+					go v.reconnect()
+
+					// This is here just to prevent violently spamming the
+					// voice reconnects
+					time.Sleep(1 * time.Second)
+
+				}
+				return
+			}
+
+			s.log(LogError, "error reconnecting to gateway, %s", err)
+
+			<-time.After(wait * time.Second)
+			wait *= 2
+			if wait > 600 {
+				wait = 600
+			}
+		}
+	}
+}
+
+// Close closes a websocket and stops all listening/heartbeat goroutines.
+// TODO: Add support for Voice WS/UDP connections
+func (s *Session) Close() (err error) {
+
+	s.log(LogInformational, "called")
+	s.Lock()
+
+	s.DataReady = false
+
+	if s.listening != nil {
+		s.log(LogInformational, "closing listening channel")
+		close(s.listening)
+		s.listening = nil
+	}
+
+	// TODO: Close all active Voice Connections too
+	// this should force stop any reconnecting voice channels too
+
+	if s.wsConn != nil {
+
+		s.log(LogInformational, "sending close frame")
+		// To cleanly close a connection, a client should send a close
+		// frame and wait for the server to close the connection.
+		err := s.wsConn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+		if err != nil {
+			s.log(LogError, "error closing websocket, %s", err)
+		}
+
+		// TODO: Wait for Discord to actually close the connection.
+		time.Sleep(1 * time.Second)
+
+		s.log(LogInformational, "closing gateway websocket")
+		err = s.wsConn.Close()
+		if err != nil {
+			s.log(LogError, "error closing websocket, %s", err)
+		}
+
+		s.wsConn = nil
+	}
+
+	s.Unlock()
+
+	s.log(LogInformational, "emit disconnect event")
+	s.handle(&Disconnect{})
+
+	return
+}

vendor/github.com/go-telegram-bot-api/telegram-bot-api/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Syfaro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/go-telegram-bot-api/telegram-bot-api/bot.go

@@ -0,0 +1,702 @@
+// Package tgbotapi has functions and types used for interacting with
+// the Telegram Bot API.
+package tgbotapi
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/technoweenie/multipartstreamer"
+)
+
+// BotAPI allows you to interact with the Telegram Bot API.
+type BotAPI struct {
+	Token  string       `json:"token"`
+	Debug  bool         `json:"debug"`
+	Self   User         `json:"-"`
+	Client *http.Client `json:"-"`
+}
+
+// NewBotAPI creates a new BotAPI instance.
+//
+// It requires a token, provided by @BotFather on Telegram.
+func NewBotAPI(token string) (*BotAPI, error) {
+	return NewBotAPIWithClient(token, &http.Client{})
+}
+
+// NewBotAPIWithClient creates a new BotAPI instance
+// and allows you to pass a http.Client.
+//
+// It requires a token, provided by @BotFather on Telegram.
+func NewBotAPIWithClient(token string, client *http.Client) (*BotAPI, error) {
+	bot := &BotAPI{
+		Token:  token,
+		Client: client,
+	}
+
+	self, err := bot.GetMe()
+	if err != nil {
+		return &BotAPI{}, err
+	}
+
+	bot.Self = self
+
+	return bot, nil
+}
+
+// MakeRequest makes a request to a specific endpoint with our token.
+func (bot *BotAPI) MakeRequest(endpoint string, params url.Values) (APIResponse, error) {
+	method := fmt.Sprintf(APIEndpoint, bot.Token, endpoint)
+
+	resp, err := bot.Client.PostForm(method, params)
+	if err != nil {
+		return APIResponse{}, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusForbidden {
+		return APIResponse{}, errors.New(ErrAPIForbidden)
+	}
+
+	bytes, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return APIResponse{}, err
+	}
+
+	if bot.Debug {
+		log.Println(endpoint, string(bytes))
+	}
+
+	var apiResp APIResponse
+	json.Unmarshal(bytes, &apiResp)
+
+	if !apiResp.Ok {
+		return apiResp, errors.New(apiResp.Description)
+	}
+
+	return apiResp, nil
+}
+
+// makeMessageRequest makes a request to a method that returns a Message.
+func (bot *BotAPI) makeMessageRequest(endpoint string, params url.Values) (Message, error) {
+	resp, err := bot.MakeRequest(endpoint, params)
+	if err != nil {
+		return Message{}, err
+	}
+
+	var message Message
+	json.Unmarshal(resp.Result, &message)
+
+	bot.debugLog(endpoint, params, message)
+
+	return message, nil
+}
+
+// UploadFile makes a request to the API with a file.
+//
+// Requires the parameter to hold the file not be in the params.
+// File should be a string to a file path, a FileBytes struct,
+// a FileReader struct, or a url.URL.
+//
+// Note that if your FileReader has a size set to -1, it will read
+// the file into memory to calculate a size.
+func (bot *BotAPI) UploadFile(endpoint string, params map[string]string, fieldname string, file interface{}) (APIResponse, error) {
+	ms := multipartstreamer.New()
+
+	switch f := file.(type) {
+	case string:
+		ms.WriteFields(params)
+
+		fileHandle, err := os.Open(f)
+		if err != nil {
+			return APIResponse{}, err
+		}
+		defer fileHandle.Close()
+
+		fi, err := os.Stat(f)
+		if err != nil {
+			return APIResponse{}, err
+		}
+
+		ms.WriteReader(fieldname, fileHandle.Name(), fi.Size(), fileHandle)
+	case FileBytes:
+		ms.WriteFields(params)
+
+		buf := bytes.NewBuffer(f.Bytes)
+		ms.WriteReader(fieldname, f.Name, int64(len(f.Bytes)), buf)
+	case FileReader:
+		ms.WriteFields(params)
+
+		if f.Size != -1 {
+			ms.WriteReader(fieldname, f.Name, f.Size, f.Reader)
+
+			break
+		}
+
+		data, err := ioutil.ReadAll(f.Reader)
+		if err != nil {
+			return APIResponse{}, err
+		}
+
+		buf := bytes.NewBuffer(data)
+
+		ms.WriteReader(fieldname, f.Name, int64(len(data)), buf)
+	case url.URL:
+		params[fieldname] = f.String()
+
+		ms.WriteFields(params)
+	default:
+		return APIResponse{}, errors.New(ErrBadFileType)
+	}
+
+	method := fmt.Sprintf(APIEndpoint, bot.Token, endpoint)
+
+	req, err := http.NewRequest("POST", method, nil)
+	if err != nil {
+		return APIResponse{}, err
+	}
+
+	ms.SetupRequest(req)
+
+	res, err := bot.Client.Do(req)
+	if err != nil {
+		return APIResponse{}, err
+	}
+	defer res.Body.Close()
+
+	bytes, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return APIResponse{}, err
+	}
+
+	if bot.Debug {
+		log.Println(string(bytes))
+	}
+
+	var apiResp APIResponse
+	json.Unmarshal(bytes, &apiResp)
+
+	if !apiResp.Ok {
+		return APIResponse{}, errors.New(apiResp.Description)
+	}
+
+	return apiResp, nil
+}
+
+// GetFileDirectURL returns direct URL to file
+//
+// It requires the FileID.
+func (bot *BotAPI) GetFileDirectURL(fileID string) (string, error) {
+	file, err := bot.GetFile(FileConfig{fileID})
+
+	if err != nil {
+		return "", err
+	}
+
+	return file.Link(bot.Token), nil
+}
+
+// GetMe fetches the currently authenticated bot.
+//
+// This method is called upon creation to validate the token,
+// and so you may get this data from BotAPI.Self without the need for
+// another request.
+func (bot *BotAPI) GetMe() (User, error) {
+	resp, err := bot.MakeRequest("getMe", nil)
+	if err != nil {
+		return User{}, err
+	}
+
+	var user User
+	json.Unmarshal(resp.Result, &user)
+
+	bot.debugLog("getMe", nil, user)
+
+	return user, nil
+}
+
+// IsMessageToMe returns true if message directed to this bot.
+//
+// It requires the Message.
+func (bot *BotAPI) IsMessageToMe(message Message) bool {
+	return strings.Contains(message.Text, "@"+bot.Self.UserName)
+}
+
+// Send will send a Chattable item to Telegram.
+//
+// It requires the Chattable to send.
+func (bot *BotAPI) Send(c Chattable) (Message, error) {
+	switch c.(type) {
+	case Fileable:
+		return bot.sendFile(c.(Fileable))
+	default:
+		return bot.sendChattable(c)
+	}
+}
+
+// debugLog checks if the bot is currently running in debug mode, and if
+// so will display information about the request and response in the
+// debug log.
+func (bot *BotAPI) debugLog(context string, v url.Values, message interface{}) {
+	if bot.Debug {
+		log.Printf("%s req : %+v\n", context, v)
+		log.Printf("%s resp: %+v\n", context, message)
+	}
+}
+
+// sendExisting will send a Message with an existing file to Telegram.
+func (bot *BotAPI) sendExisting(method string, config Fileable) (Message, error) {
+	v, err := config.values()
+
+	if err != nil {
+		return Message{}, err
+	}
+
+	message, err := bot.makeMessageRequest(method, v)
+	if err != nil {
+		return Message{}, err
+	}
+
+	return message, nil
+}
+
+// uploadAndSend will send a Message with a new file to Telegram.
+func (bot *BotAPI) uploadAndSend(method string, config Fileable) (Message, error) {
+	params, err := config.params()
+	if err != nil {
+		return Message{}, err
+	}
+
+	file := config.getFile()
+
+	resp, err := bot.UploadFile(method, params, config.name(), file)
+	if err != nil {
+		return Message{}, err
+	}
+
+	var message Message
+	json.Unmarshal(resp.Result, &message)
+
+	bot.debugLog(method, nil, message)
+
+	return message, nil
+}
+
+// sendFile determines if the file is using an existing file or uploading
+// a new file, then sends it as needed.
+func (bot *BotAPI) sendFile(config Fileable) (Message, error) {
+	if config.useExistingFile() {
+		return bot.sendExisting(config.method(), config)
+	}
+
+	return bot.uploadAndSend(config.method(), config)
+}
+
+// sendChattable sends a Chattable.
+func (bot *BotAPI) sendChattable(config Chattable) (Message, error) {
+	v, err := config.values()
+	if err != nil {
+		return Message{}, err
+	}
+
+	message, err := bot.makeMessageRequest(config.method(), v)
+
+	if err != nil {
+		return Message{}, err
+	}
+
+	return message, nil
+}
+
+// GetUserProfilePhotos gets a user's profile photos.
+//
+// It requires UserID.
+// Offset and Limit are optional.
+func (bot *BotAPI) GetUserProfilePhotos(config UserProfilePhotosConfig) (UserProfilePhotos, error) {
+	v := url.Values{}
+	v.Add("user_id", strconv.Itoa(config.UserID))
+	if config.Offset != 0 {
+		v.Add("offset", strconv.Itoa(config.Offset))
+	}
+	if config.Limit != 0 {
+		v.Add("limit", strconv.Itoa(config.Limit))
+	}
+
+	resp, err := bot.MakeRequest("getUserProfilePhotos", v)
+	if err != nil {
+		return UserProfilePhotos{}, err
+	}
+
+	var profilePhotos UserProfilePhotos
+	json.Unmarshal(resp.Result, &profilePhotos)
+
+	bot.debugLog("GetUserProfilePhoto", v, profilePhotos)
+
+	return profilePhotos, nil
+}
+
+// GetFile returns a File which can download a file from Telegram.
+//
+// Requires FileID.
+func (bot *BotAPI) GetFile(config FileConfig) (File, error) {
+	v := url.Values{}
+	v.Add("file_id", config.FileID)
+
+	resp, err := bot.MakeRequest("getFile", v)
+	if err != nil {
+		return File{}, err
+	}
+
+	var file File
+	json.Unmarshal(resp.Result, &file)
+
+	bot.debugLog("GetFile", v, file)
+
+	return file, nil
+}
+
+// GetUpdates fetches updates.
+// If a WebHook is set, this will not return any data!
+//
+// Offset, Limit, and Timeout are optional.
+// To avoid stale items, set Offset to one higher than the previous item.
+// Set Timeout to a large number to reduce requests so you can get updates
+// instantly instead of having to wait between requests.
+func (bot *BotAPI) GetUpdates(config UpdateConfig) ([]Update, error) {
+	v := url.Values{}
+	if config.Offset != 0 {
+		v.Add("offset", strconv.Itoa(config.Offset))
+	}
+	if config.Limit > 0 {
+		v.Add("limit", strconv.Itoa(config.Limit))
+	}
+	if config.Timeout > 0 {
+		v.Add("timeout", strconv.Itoa(config.Timeout))
+	}
+
+	resp, err := bot.MakeRequest("getUpdates", v)
+	if err != nil {
+		return []Update{}, err
+	}
+
+	var updates []Update
+	json.Unmarshal(resp.Result, &updates)
+
+	bot.debugLog("getUpdates", v, updates)
+
+	return updates, nil
+}
+
+// RemoveWebhook unsets the webhook.
+func (bot *BotAPI) RemoveWebhook() (APIResponse, error) {
+	return bot.MakeRequest("setWebhook", url.Values{})
+}
+
+// SetWebhook sets a webhook.
+//
+// If this is set, GetUpdates will not get any data!
+//
+// If you do not have a legitimate TLS certificate, you need to include
+// your self signed certificate with the config.
+func (bot *BotAPI) SetWebhook(config WebhookConfig) (APIResponse, error) {
+
+	if config.Certificate == nil {
+		v := url.Values{}
+		v.Add("url", config.URL.String())
+		if config.MaxConnections != 0 {
+			v.Add("max_connections", strconv.Itoa(config.MaxConnections))
+		}
+
+		return bot.MakeRequest("setWebhook", v)
+	}
+
+	params := make(map[string]string)
+	params["url"] = config.URL.String()
+	if config.MaxConnections != 0 {
+		params["max_connections"] = strconv.Itoa(config.MaxConnections)
+	}
+
+	resp, err := bot.UploadFile("setWebhook", params, "certificate", config.Certificate)
+	if err != nil {
+		return APIResponse{}, err
+	}
+
+	var apiResp APIResponse
+	json.Unmarshal(resp.Result, &apiResp)
+
+	if bot.Debug {
+		log.Printf("setWebhook resp: %+v\n", apiResp)
+	}
+
+	return apiResp, nil
+}
+
+// GetWebhookInfo allows you to fetch information about a webhook and if
+// one currently is set, along with pending update count and error messages.
+func (bot *BotAPI) GetWebhookInfo() (WebhookInfo, error) {
+	resp, err := bot.MakeRequest("getWebhookInfo", url.Values{})
+	if err != nil {
+		return WebhookInfo{}, err
+	}
+
+	var info WebhookInfo
+	err = json.Unmarshal(resp.Result, &info)
+
+	return info, err
+}
+
+// GetUpdatesChan starts and returns a channel for getting updates.
+func (bot *BotAPI) GetUpdatesChan(config UpdateConfig) (UpdatesChannel, error) {
+	ch := make(chan Update, 100)
+
+	go func() {
+		for {
+			updates, err := bot.GetUpdates(config)
+			if err != nil {
+				log.Println(err)
+				log.Println("Failed to get updates, retrying in 3 seconds...")
+				time.Sleep(time.Second * 3)
+
+				continue
+			}
+
+			for _, update := range updates {
+				if update.UpdateID >= config.Offset {
+					config.Offset = update.UpdateID + 1
+					ch <- update
+				}
+			}
+		}
+	}()
+
+	return ch, nil
+}
+
+// ListenForWebhook registers a http handler for a webhook.
+func (bot *BotAPI) ListenForWebhook(pattern string) UpdatesChannel {
+	ch := make(chan Update, 100)
+
+	http.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
+		bytes, _ := ioutil.ReadAll(r.Body)
+
+		var update Update
+		json.Unmarshal(bytes, &update)
+
+		ch <- update
+	})
+
+	return ch
+}
+
+// AnswerInlineQuery sends a response to an inline query.
+//
+// Note that you must respond to an inline query within 30 seconds.
+func (bot *BotAPI) AnswerInlineQuery(config InlineConfig) (APIResponse, error) {
+	v := url.Values{}
+
+	v.Add("inline_query_id", config.InlineQueryID)
+	v.Add("cache_time", strconv.Itoa(config.CacheTime))
+	v.Add("is_personal", strconv.FormatBool(config.IsPersonal))
+	v.Add("next_offset", config.NextOffset)
+	data, err := json.Marshal(config.Results)
+	if err != nil {
+		return APIResponse{}, err
+	}
+	v.Add("results", string(data))
+	v.Add("switch_pm_text", config.SwitchPMText)
+	v.Add("switch_pm_parameter", config.SwitchPMParameter)
+
+	bot.debugLog("answerInlineQuery", v, nil)
+
+	return bot.MakeRequest("answerInlineQuery", v)
+}
+
+// AnswerCallbackQuery sends a response to an inline query callback.
+func (bot *BotAPI) AnswerCallbackQuery(config CallbackConfig) (APIResponse, error) {
+	v := url.Values{}
+
+	v.Add("callback_query_id", config.CallbackQueryID)
+	if config.Text != "" {
+		v.Add("text", config.Text)
+	}
+	v.Add("show_alert", strconv.FormatBool(config.ShowAlert))
+	if config.URL != "" {
+		v.Add("url", config.URL)
+	}
+	v.Add("cache_time", strconv.Itoa(config.CacheTime))
+
+	bot.debugLog("answerCallbackQuery", v, nil)
+
+	return bot.MakeRequest("answerCallbackQuery", v)
+}
+
+// KickChatMember kicks a user from a chat. Note that this only will work
+// in supergroups, and requires the bot to be an admin. Also note they
+// will be unable to rejoin until they are unbanned.
+func (bot *BotAPI) KickChatMember(config ChatMemberConfig) (APIResponse, error) {
+	v := url.Values{}
+
+	if config.SuperGroupUsername == "" {
+		v.Add("chat_id", strconv.FormatInt(config.ChatID, 10))
+	} else {
+		v.Add("chat_id", config.SuperGroupUsername)
+	}
+	v.Add("user_id", strconv.Itoa(config.UserID))
+
+	bot.debugLog("kickChatMember", v, nil)
+
+	return bot.MakeRequest("kickChatMember", v)
+}
+
+// LeaveChat makes the bot leave the chat.
+func (bot *BotAPI) LeaveChat(config ChatConfig) (APIResponse, error) {
+	v := url.Values{}
+
+	if config.SuperGroupUsername == "" {
+		v.Add("chat_id", strconv.FormatInt(config.ChatID, 10))
+	} else {
+		v.Add("chat_id", config.SuperGroupUsername)
+	}
+
+	bot.debugLog("leaveChat", v, nil)
+
+	return bot.MakeRequest("leaveChat", v)
+}
+
+// GetChat gets information about a chat.
+func (bot *BotAPI) GetChat(config ChatConfig) (Chat, error) {
+	v := url.Values{}
+
+	if config.SuperGroupUsername == "" {
+		v.Add("chat_id", strconv.FormatInt(config.ChatID, 10))
+	} else {
+		v.Add("chat_id", config.SuperGroupUsername)
+	}
+
+	resp, err := bot.MakeRequest("getChat", v)
+	if err != nil {
+		return Chat{}, err
+	}
+
+	var chat Chat
+	err = json.Unmarshal(resp.Result, &chat)
+
+	bot.debugLog("getChat", v, chat)
+
+	return chat, err
+}
+
+// GetChatAdministrators gets a list of administrators in the chat.
+//
+// If none have been appointed, only the creator will be returned.
+// Bots are not shown, even if they are an administrator.
+func (bot *BotAPI) GetChatAdministrators(config ChatConfig) ([]ChatMember, error) {
+	v := url.Values{}
+
+	if config.SuperGroupUsername == "" {
+		v.Add("chat_id", strconv.FormatInt(config.ChatID, 10))
+	} else {
+		v.Add("chat_id", config.SuperGroupUsername)
+	}
+
+	resp, err := bot.MakeRequest("getChatAdministrators", v)
+	if err != nil {
+		return []ChatMember{}, err
+	}
+
+	var members []ChatMember
+	err = json.Unmarshal(resp.Result, &members)
+
+	bot.debugLog("getChatAdministrators", v, members)
+
+	return members, err
+}
+
+// GetChatMembersCount gets the number of users in a chat.
+func (bot *BotAPI) GetChatMembersCount(config ChatConfig) (int, error) {
+	v := url.Values{}
+
+	if config.SuperGroupUsername == "" {
+		v.Add("chat_id", strconv.FormatInt(config.ChatID, 10))
+	} else {
+		v.Add("chat_id", config.SuperGroupUsername)
+	}
+
+	resp, err := bot.MakeRequest("getChatMembersCount", v)
+	if err != nil {
+		return -1, err
+	}
+
+	var count int
+	err = json.Unmarshal(resp.Result, &count)
+
+	bot.debugLog("getChatMembersCount", v, count)
+
+	return count, err
+}
+
+// GetChatMember gets a specific chat member.
+func (bot *BotAPI) GetChatMember(config ChatConfigWithUser) (ChatMember, error) {
+	v := url.Values{}
+
+	if config.SuperGroupUsername == "" {
+		v.Add("chat_id", strconv.FormatInt(config.ChatID, 10))
+	} else {
+		v.Add("chat_id", config.SuperGroupUsername)
+	}
+	v.Add("user_id", strconv.Itoa(config.UserID))
+
+	resp, err := bot.MakeRequest("getChatMember", v)
+	if err != nil {
+		return ChatMember{}, err
+	}
+
+	var member ChatMember
+	err = json.Unmarshal(resp.Result, &member)
+
+	bot.debugLog("getChatMember", v, member)
+
+	return member, err
+}
+
+// UnbanChatMember unbans a user from a chat. Note that this only will work
+// in supergroups, and requires the bot to be an admin.
+func (bot *BotAPI) UnbanChatMember(config ChatMemberConfig) (APIResponse, error) {
+	v := url.Values{}
+
+	if config.SuperGroupUsername == "" {
+		v.Add("chat_id", strconv.FormatInt(config.ChatID, 10))
+	} else {
+		v.Add("chat_id", config.SuperGroupUsername)
+	}
+	v.Add("user_id", strconv.Itoa(config.UserID))
+
+	bot.debugLog("unbanChatMember", v, nil)
+
+	return bot.MakeRequest("unbanChatMember", v)
+}
+
+// GetGameHighScores allows you to get the high scores for a game.
+func (bot *BotAPI) GetGameHighScores(config GetGameHighScoresConfig) ([]GameHighScore, error) {
+	v, _ := config.values()
+
+	resp, err := bot.MakeRequest(config.method(), v)
+	if err != nil {
+		return []GameHighScore{}, err
+	}
+
+	var highScores []GameHighScore
+	err = json.Unmarshal(resp.Result, &highScores)
+
+	return highScores, err
+}

vendor/github.com/go-telegram-bot-api/telegram-bot-api/configs.go

@@ -0,0 +1,832 @@
+package tgbotapi
+
+import (
+	"encoding/json"
+	"io"
+	"net/url"
+	"strconv"
+)
+
+// Telegram constants
+const (
+	// APIEndpoint is the endpoint for all API methods,
+	// with formatting for Sprintf.
+	APIEndpoint = "https://api.telegram.org/bot%s/%s"
+	// FileEndpoint is the endpoint for downloading a file from Telegram.
+	FileEndpoint = "https://api.telegram.org/file/bot%s/%s"
+)
+
+// Constant values for ChatActions
+const (
+	ChatTyping         = "typing"
+	ChatUploadPhoto    = "upload_photo"
+	ChatRecordVideo    = "record_video"
+	ChatUploadVideo    = "upload_video"
+	ChatRecordAudio    = "record_audio"
+	ChatUploadAudio    = "upload_audio"
+	ChatUploadDocument = "upload_document"
+	ChatFindLocation   = "find_location"
+)
+
+// API errors
+const (
+	// ErrAPIForbidden happens when a token is bad
+	ErrAPIForbidden = "forbidden"
+)
+
+// Constant values for ParseMode in MessageConfig
+const (
+	ModeMarkdown = "Markdown"
+	ModeHTML     = "HTML"
+)
+
+// Library errors
+const (
+	// ErrBadFileType happens when you pass an unknown type
+	ErrBadFileType = "bad file type"
+	ErrBadURL      = "bad or empty url"
+)
+
+// Chattable is any config type that can be sent.
+type Chattable interface {
+	values() (url.Values, error)
+	method() string
+}
+
+// Fileable is any config type that can be sent that includes a file.
+type Fileable interface {
+	Chattable
+	params() (map[string]string, error)
+	name() string
+	getFile() interface{}
+	useExistingFile() bool
+}
+
+// BaseChat is base type for all chat config types.
+type BaseChat struct {
+	ChatID              int64 // required
+	ChannelUsername     string
+	ReplyToMessageID    int
+	ReplyMarkup         interface{}
+	DisableNotification bool
+}
+
+// values returns url.Values representation of BaseChat
+func (chat *BaseChat) values() (url.Values, error) {
+	v := url.Values{}
+	if chat.ChannelUsername != "" {
+		v.Add("chat_id", chat.ChannelUsername)
+	} else {
+		v.Add("chat_id", strconv.FormatInt(chat.ChatID, 10))
+	}
+
+	if chat.ReplyToMessageID != 0 {
+		v.Add("reply_to_message_id", strconv.Itoa(chat.ReplyToMessageID))
+	}
+
+	if chat.ReplyMarkup != nil {
+		data, err := json.Marshal(chat.ReplyMarkup)
+		if err != nil {
+			return v, err
+		}
+
+		v.Add("reply_markup", string(data))
+	}
+
+	v.Add("disable_notification", strconv.FormatBool(chat.DisableNotification))
+
+	return v, nil
+}
+
+// BaseFile is a base type for all file config types.
+type BaseFile struct {
+	BaseChat
+	File        interface{}
+	FileID      string
+	UseExisting bool
+	MimeType    string
+	FileSize    int
+}
+
+// params returns a map[string]string representation of BaseFile.
+func (file BaseFile) params() (map[string]string, error) {
+	params := make(map[string]string)
+
+	if file.ChannelUsername != "" {
+		params["chat_id"] = file.ChannelUsername
+	} else {
+		params["chat_id"] = strconv.FormatInt(file.ChatID, 10)
+	}
+
+	if file.ReplyToMessageID != 0 {
+		params["reply_to_message_id"] = strconv.Itoa(file.ReplyToMessageID)
+	}
+
+	if file.ReplyMarkup != nil {
+		data, err := json.Marshal(file.ReplyMarkup)
+		if err != nil {
+			return params, err
+		}
+
+		params["reply_markup"] = string(data)
+	}
+
+	if file.MimeType != "" {
+		params["mime_type"] = file.MimeType
+	}
+
+	if file.FileSize > 0 {
+		params["file_size"] = strconv.Itoa(file.FileSize)
+	}
+
+	params["disable_notification"] = strconv.FormatBool(file.DisableNotification)
+
+	return params, nil
+}
+
+// getFile returns the file.
+func (file BaseFile) getFile() interface{} {
+	return file.File
+}
+
+// useExistingFile returns if the BaseFile has already been uploaded.
+func (file BaseFile) useExistingFile() bool {
+	return file.UseExisting
+}
+
+// BaseEdit is base type of all chat edits.
+type BaseEdit struct {
+	ChatID          int64
+	ChannelUsername string
+	MessageID       int
+	InlineMessageID string
+	ReplyMarkup     *InlineKeyboardMarkup
+}
+
+func (edit BaseEdit) values() (url.Values, error) {
+	v := url.Values{}
+
+	if edit.InlineMessageID == "" {
+		if edit.ChannelUsername != "" {
+			v.Add("chat_id", edit.ChannelUsername)
+		} else {
+			v.Add("chat_id", strconv.FormatInt(edit.ChatID, 10))
+		}
+		v.Add("message_id", strconv.Itoa(edit.MessageID))
+	} else {
+		v.Add("inline_message_id", edit.InlineMessageID)
+	}
+
+	if edit.ReplyMarkup != nil {
+		data, err := json.Marshal(edit.ReplyMarkup)
+		if err != nil {
+			return v, err
+		}
+		v.Add("reply_markup", string(data))
+	}
+
+	return v, nil
+}
+
+// MessageConfig contains information about a SendMessage request.
+type MessageConfig struct {
+	BaseChat
+	Text                  string
+	ParseMode             string
+	DisableWebPagePreview bool
+}
+
+// values returns a url.Values representation of MessageConfig.
+func (config MessageConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+	v.Add("text", config.Text)
+	v.Add("disable_web_page_preview", strconv.FormatBool(config.DisableWebPagePreview))
+	if config.ParseMode != "" {
+		v.Add("parse_mode", config.ParseMode)
+	}
+
+	return v, nil
+}
+
+// method returns Telegram API method name for sending Message.
+func (config MessageConfig) method() string {
+	return "sendMessage"
+}
+
+// ForwardConfig contains information about a ForwardMessage request.
+type ForwardConfig struct {
+	BaseChat
+	FromChatID          int64 // required
+	FromChannelUsername string
+	MessageID           int // required
+}
+
+// values returns a url.Values representation of ForwardConfig.
+func (config ForwardConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+	v.Add("from_chat_id", strconv.FormatInt(config.FromChatID, 10))
+	v.Add("message_id", strconv.Itoa(config.MessageID))
+	return v, nil
+}
+
+// method returns Telegram API method name for sending Forward.
+func (config ForwardConfig) method() string {
+	return "forwardMessage"
+}
+
+// PhotoConfig contains information about a SendPhoto request.
+type PhotoConfig struct {
+	BaseFile
+	Caption string
+}
+
+// Params returns a map[string]string representation of PhotoConfig.
+func (config PhotoConfig) params() (map[string]string, error) {
+	params, _ := config.BaseFile.params()
+
+	if config.Caption != "" {
+		params["caption"] = config.Caption
+	}
+
+	return params, nil
+}
+
+// Values returns a url.Values representation of PhotoConfig.
+func (config PhotoConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add(config.name(), config.FileID)
+	if config.Caption != "" {
+		v.Add("caption", config.Caption)
+	}
+	return v, nil
+}
+
+// name returns the field name for the Photo.
+func (config PhotoConfig) name() string {
+	return "photo"
+}
+
+// method returns Telegram API method name for sending Photo.
+func (config PhotoConfig) method() string {
+	return "sendPhoto"
+}
+
+// AudioConfig contains information about a SendAudio request.
+type AudioConfig struct {
+	BaseFile
+	Caption   string
+	Duration  int
+	Performer string
+	Title     string
+}
+
+// values returns a url.Values representation of AudioConfig.
+func (config AudioConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add(config.name(), config.FileID)
+	if config.Duration != 0 {
+		v.Add("duration", strconv.Itoa(config.Duration))
+	}
+
+	if config.Performer != "" {
+		v.Add("performer", config.Performer)
+	}
+	if config.Title != "" {
+		v.Add("title", config.Title)
+	}
+	if config.Caption != "" {
+		v.Add("caption", config.Caption)
+	}
+
+	return v, nil
+}
+
+// params returns a map[string]string representation of AudioConfig.
+func (config AudioConfig) params() (map[string]string, error) {
+	params, _ := config.BaseFile.params()
+
+	if config.Duration != 0 {
+		params["duration"] = strconv.Itoa(config.Duration)
+	}
+
+	if config.Performer != "" {
+		params["performer"] = config.Performer
+	}
+	if config.Title != "" {
+		params["title"] = config.Title
+	}
+	if config.Caption != "" {
+		params["caption"] = config.Caption
+	}
+
+	return params, nil
+}
+
+// name returns the field name for the Audio.
+func (config AudioConfig) name() string {
+	return "audio"
+}
+
+// method returns Telegram API method name for sending Audio.
+func (config AudioConfig) method() string {
+	return "sendAudio"
+}
+
+// DocumentConfig contains information about a SendDocument request.
+type DocumentConfig struct {
+	BaseFile
+}
+
+// values returns a url.Values representation of DocumentConfig.
+func (config DocumentConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add(config.name(), config.FileID)
+
+	return v, nil
+}
+
+// params returns a map[string]string representation of DocumentConfig.
+func (config DocumentConfig) params() (map[string]string, error) {
+	params, _ := config.BaseFile.params()
+
+	return params, nil
+}
+
+// name returns the field name for the Document.
+func (config DocumentConfig) name() string {
+	return "document"
+}
+
+// method returns Telegram API method name for sending Document.
+func (config DocumentConfig) method() string {
+	return "sendDocument"
+}
+
+// StickerConfig contains information about a SendSticker request.
+type StickerConfig struct {
+	BaseFile
+}
+
+// values returns a url.Values representation of StickerConfig.
+func (config StickerConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add(config.name(), config.FileID)
+
+	return v, nil
+}
+
+// params returns a map[string]string representation of StickerConfig.
+func (config StickerConfig) params() (map[string]string, error) {
+	params, _ := config.BaseFile.params()
+
+	return params, nil
+}
+
+// name returns the field name for the Sticker.
+func (config StickerConfig) name() string {
+	return "sticker"
+}
+
+// method returns Telegram API method name for sending Sticker.
+func (config StickerConfig) method() string {
+	return "sendSticker"
+}
+
+// VideoConfig contains information about a SendVideo request.
+type VideoConfig struct {
+	BaseFile
+	Duration int
+	Caption  string
+}
+
+// values returns a url.Values representation of VideoConfig.
+func (config VideoConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add(config.name(), config.FileID)
+	if config.Duration != 0 {
+		v.Add("duration", strconv.Itoa(config.Duration))
+	}
+	if config.Caption != "" {
+		v.Add("caption", config.Caption)
+	}
+
+	return v, nil
+}
+
+// params returns a map[string]string representation of VideoConfig.
+func (config VideoConfig) params() (map[string]string, error) {
+	params, _ := config.BaseFile.params()
+
+	return params, nil
+}
+
+// name returns the field name for the Video.
+func (config VideoConfig) name() string {
+	return "video"
+}
+
+// method returns Telegram API method name for sending Video.
+func (config VideoConfig) method() string {
+	return "sendVideo"
+}
+
+// VoiceConfig contains information about a SendVoice request.
+type VoiceConfig struct {
+	BaseFile
+	Caption  string
+	Duration int
+}
+
+// values returns a url.Values representation of VoiceConfig.
+func (config VoiceConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add(config.name(), config.FileID)
+	if config.Duration != 0 {
+		v.Add("duration", strconv.Itoa(config.Duration))
+	}
+
+	return v, nil
+}
+
+// params returns a map[string]string representation of VoiceConfig.
+func (config VoiceConfig) params() (map[string]string, error) {
+	params, _ := config.BaseFile.params()
+
+	if config.Duration != 0 {
+		params["duration"] = strconv.Itoa(config.Duration)
+	}
+
+	return params, nil
+}
+
+// name returns the field name for the Voice.
+func (config VoiceConfig) name() string {
+	return "voice"
+}
+
+// method returns Telegram API method name for sending Voice.
+func (config VoiceConfig) method() string {
+	return "sendVoice"
+}
+
+// LocationConfig contains information about a SendLocation request.
+type LocationConfig struct {
+	BaseChat
+	Latitude  float64 // required
+	Longitude float64 // required
+}
+
+// values returns a url.Values representation of LocationConfig.
+func (config LocationConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add("latitude", strconv.FormatFloat(config.Latitude, 'f', 6, 64))
+	v.Add("longitude", strconv.FormatFloat(config.Longitude, 'f', 6, 64))
+
+	return v, nil
+}
+
+// method returns Telegram API method name for sending Location.
+func (config LocationConfig) method() string {
+	return "sendLocation"
+}
+
+// VenueConfig contains information about a SendVenue request.
+type VenueConfig struct {
+	BaseChat
+	Latitude     float64 // required
+	Longitude    float64 // required
+	Title        string  // required
+	Address      string  // required
+	FoursquareID string
+}
+
+func (config VenueConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add("latitude", strconv.FormatFloat(config.Latitude, 'f', 6, 64))
+	v.Add("longitude", strconv.FormatFloat(config.Longitude, 'f', 6, 64))
+	v.Add("title", config.Title)
+	v.Add("address", config.Address)
+	if config.FoursquareID != "" {
+		v.Add("foursquare_id", config.FoursquareID)
+	}
+
+	return v, nil
+}
+
+func (config VenueConfig) method() string {
+	return "sendVenue"
+}
+
+// ContactConfig allows you to send a contact.
+type ContactConfig struct {
+	BaseChat
+	PhoneNumber string
+	FirstName   string
+	LastName    string
+}
+
+func (config ContactConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add("phone_number", config.PhoneNumber)
+	v.Add("first_name", config.FirstName)
+	v.Add("last_name", config.LastName)
+
+	return v, nil
+}
+
+func (config ContactConfig) method() string {
+	return "sendContact"
+}
+
+// GameConfig allows you to send a game.
+type GameConfig struct {
+	BaseChat
+	GameShortName string
+}
+
+func (config GameConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add("game_short_name", config.GameShortName)
+
+	return v, nil
+}
+
+func (config GameConfig) method() string {
+	return "sendGame"
+}
+
+// SetGameScoreConfig allows you to update the game score in a chat.
+type SetGameScoreConfig struct {
+	UserID             int
+	Score              int
+	Force              bool
+	DisableEditMessage bool
+	ChatID             int
+	ChannelUsername    string
+	MessageID          int
+	InlineMessageID    string
+}
+
+func (config SetGameScoreConfig) values() (url.Values, error) {
+	v := url.Values{}
+
+	v.Add("user_id", strconv.Itoa(config.UserID))
+	v.Add("score", strconv.Itoa(config.Score))
+	if config.InlineMessageID == "" {
+		if config.ChannelUsername == "" {
+			v.Add("chat_id", strconv.Itoa(config.ChatID))
+		} else {
+			v.Add("chat_id", config.ChannelUsername)
+		}
+		v.Add("message_id", strconv.Itoa(config.MessageID))
+	} else {
+		v.Add("inline_message_id", config.InlineMessageID)
+	}
+	v.Add("disable_edit_message", strconv.FormatBool(config.DisableEditMessage))
+
+	return v, nil
+}
+
+func (config SetGameScoreConfig) method() string {
+	return "setGameScore"
+}
+
+// GetGameHighScoresConfig allows you to fetch the high scores for a game.
+type GetGameHighScoresConfig struct {
+	UserID          int
+	ChatID          int
+	ChannelUsername string
+	MessageID       int
+	InlineMessageID string
+}
+
+func (config GetGameHighScoresConfig) values() (url.Values, error) {
+	v := url.Values{}
+
+	v.Add("user_id", strconv.Itoa(config.UserID))
+	if config.InlineMessageID == "" {
+		if config.ChannelUsername == "" {
+			v.Add("chat_id", strconv.Itoa(config.ChatID))
+		} else {
+			v.Add("chat_id", config.ChannelUsername)
+		}
+		v.Add("message_id", strconv.Itoa(config.MessageID))
+	} else {
+		v.Add("inline_message_id", config.InlineMessageID)
+	}
+
+	return v, nil
+}
+
+func (config GetGameHighScoresConfig) method() string {
+	return "getGameHighScores"
+}
+
+// ChatActionConfig contains information about a SendChatAction request.
+type ChatActionConfig struct {
+	BaseChat
+	Action string // required
+}
+
+// values returns a url.Values representation of ChatActionConfig.
+func (config ChatActionConfig) values() (url.Values, error) {
+	v, err := config.BaseChat.values()
+	if err != nil {
+		return v, err
+	}
+	v.Add("action", config.Action)
+	return v, nil
+}
+
+// method returns Telegram API method name for sending ChatAction.
+func (config ChatActionConfig) method() string {
+	return "sendChatAction"
+}
+
+// EditMessageTextConfig allows you to modify the text in a message.
+type EditMessageTextConfig struct {
+	BaseEdit
+	Text                  string
+	ParseMode             string
+	DisableWebPagePreview bool
+}
+
+func (config EditMessageTextConfig) values() (url.Values, error) {
+	v, err := config.BaseEdit.values()
+	if err != nil {
+		return v, err
+	}
+
+	v.Add("text", config.Text)
+	v.Add("parse_mode", config.ParseMode)
+	v.Add("disable_web_page_preview", strconv.FormatBool(config.DisableWebPagePreview))
+
+	return v, nil
+}
+
+func (config EditMessageTextConfig) method() string {
+	return "editMessageText"
+}
+
+// EditMessageCaptionConfig allows you to modify the caption of a message.
+type EditMessageCaptionConfig struct {
+	BaseEdit
+	Caption string
+}
+
+func (config EditMessageCaptionConfig) values() (url.Values, error) {
+	v, _ := config.BaseEdit.values()
+
+	v.Add("caption", config.Caption)
+
+	return v, nil
+}
+
+func (config EditMessageCaptionConfig) method() string {
+	return "editMessageCaption"
+}
+
+// EditMessageReplyMarkupConfig allows you to modify the reply markup
+// of a message.
+type EditMessageReplyMarkupConfig struct {
+	BaseEdit
+}
+
+func (config EditMessageReplyMarkupConfig) values() (url.Values, error) {
+	return config.BaseEdit.values()
+}
+
+func (config EditMessageReplyMarkupConfig) method() string {
+	return "editMessageReplyMarkup"
+}
+
+// UserProfilePhotosConfig contains information about a
+// GetUserProfilePhotos request.
+type UserProfilePhotosConfig struct {
+	UserID int
+	Offset int
+	Limit  int
+}
+
+// FileConfig has information about a file hosted on Telegram.
+type FileConfig struct {
+	FileID string
+}
+
+// UpdateConfig contains information about a GetUpdates request.
+type UpdateConfig struct {
+	Offset  int
+	Limit   int
+	Timeout int
+}
+
+// WebhookConfig contains information about a SetWebhook request.
+type WebhookConfig struct {
+	URL         *url.URL
+	Certificate interface{}
+	MaxConnections int
+}
+
+// FileBytes contains information about a set of bytes to upload
+// as a File.
+type FileBytes struct {
+	Name  string
+	Bytes []byte
+}
+
+// FileReader contains information about a reader to upload as a File.
+// If Size is -1, it will read the entire Reader into memory to
+// calculate a Size.
+type FileReader struct {
+	Name   string
+	Reader io.Reader
+	Size   int64
+}
+
+// InlineConfig contains information on making an InlineQuery response.
+type InlineConfig struct {
+	InlineQueryID     string        `json:"inline_query_id"`
+	Results           []interface{} `json:"results"`
+	CacheTime         int           `json:"cache_time"`
+	IsPersonal        bool          `json:"is_personal"`
+	NextOffset        string        `json:"next_offset"`
+	SwitchPMText      string        `json:"switch_pm_text"`
+	SwitchPMParameter string        `json:"switch_pm_parameter"`
+}
+
+// CallbackConfig contains information on making a CallbackQuery response.
+type CallbackConfig struct {
+	CallbackQueryID string `json:"callback_query_id"`
+	Text            string `json:"text"`
+	ShowAlert       bool   `json:"show_alert"`
+	URL             string `json:"url"`
+	CacheTime       int    `json:"cache_time"`
+}
+
+// ChatMemberConfig contains information about a user in a chat for use
+// with administrative functions such as kicking or unbanning a user.
+type ChatMemberConfig struct {
+	ChatID             int64
+	SuperGroupUsername string
+	UserID             int
+}
+
+// ChatConfig contains information about getting information on a chat.
+type ChatConfig struct {
+	ChatID             int64
+	SuperGroupUsername string
+}
+
+// ChatConfigWithUser contains information about getting information on
+// a specific user within a chat.
+type ChatConfigWithUser struct {
+	ChatID             int64
+	SuperGroupUsername string
+	UserID             int
+}

vendor/github.com/go-telegram-bot-api/telegram-bot-api/helpers.go

@@ -0,0 +1,626 @@
+package tgbotapi
+
+import (
+	"log"
+	"net/url"
+)
+
+// NewMessage creates a new Message.
+//
+// chatID is where to send it, text is the message text.
+func NewMessage(chatID int64, text string) MessageConfig {
+	return MessageConfig{
+		BaseChat: BaseChat{
+			ChatID:           chatID,
+			ReplyToMessageID: 0,
+		},
+		Text: text,
+		DisableWebPagePreview: false,
+	}
+}
+
+// NewMessageToChannel creates a new Message that is sent to a channel
+// by username.
+//
+// username is the username of the channel, text is the message text.
+func NewMessageToChannel(username string, text string) MessageConfig {
+	return MessageConfig{
+		BaseChat: BaseChat{
+			ChannelUsername: username,
+		},
+		Text: text,
+	}
+}
+
+// NewForward creates a new forward.
+//
+// chatID is where to send it, fromChatID is the source chat,
+// and messageID is the ID of the original message.
+func NewForward(chatID int64, fromChatID int64, messageID int) ForwardConfig {
+	return ForwardConfig{
+		BaseChat:   BaseChat{ChatID: chatID},
+		FromChatID: fromChatID,
+		MessageID:  messageID,
+	}
+}
+
+// NewPhotoUpload creates a new photo uploader.
+//
+// chatID is where to send it, file is a string path to the file,
+// FileReader, or FileBytes.
+//
+// Note that you must send animated GIFs as a document.
+func NewPhotoUpload(chatID int64, file interface{}) PhotoConfig {
+	return PhotoConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			File:        file,
+			UseExisting: false,
+		},
+	}
+}
+
+// NewPhotoShare shares an existing photo.
+// You may use this to reshare an existing photo without reuploading it.
+//
+// chatID is where to send it, fileID is the ID of the file
+// already uploaded.
+func NewPhotoShare(chatID int64, fileID string) PhotoConfig {
+	return PhotoConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			FileID:      fileID,
+			UseExisting: true,
+		},
+	}
+}
+
+// NewAudioUpload creates a new audio uploader.
+//
+// chatID is where to send it, file is a string path to the file,
+// FileReader, or FileBytes.
+func NewAudioUpload(chatID int64, file interface{}) AudioConfig {
+	return AudioConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			File:        file,
+			UseExisting: false,
+		},
+	}
+}
+
+// NewAudioShare shares an existing audio file.
+// You may use this to reshare an existing audio file without
+// reuploading it.
+//
+// chatID is where to send it, fileID is the ID of the audio
+// already uploaded.
+func NewAudioShare(chatID int64, fileID string) AudioConfig {
+	return AudioConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			FileID:      fileID,
+			UseExisting: true,
+		},
+	}
+}
+
+// NewDocumentUpload creates a new document uploader.
+//
+// chatID is where to send it, file is a string path to the file,
+// FileReader, or FileBytes.
+func NewDocumentUpload(chatID int64, file interface{}) DocumentConfig {
+	return DocumentConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			File:        file,
+			UseExisting: false,
+		},
+	}
+}
+
+// NewDocumentShare shares an existing document.
+// You may use this to reshare an existing document without
+// reuploading it.
+//
+// chatID is where to send it, fileID is the ID of the document
+// already uploaded.
+func NewDocumentShare(chatID int64, fileID string) DocumentConfig {
+	return DocumentConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			FileID:      fileID,
+			UseExisting: true,
+		},
+	}
+}
+
+// NewStickerUpload creates a new sticker uploader.
+//
+// chatID is where to send it, file is a string path to the file,
+// FileReader, or FileBytes.
+func NewStickerUpload(chatID int64, file interface{}) StickerConfig {
+	return StickerConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			File:        file,
+			UseExisting: false,
+		},
+	}
+}
+
+// NewStickerShare shares an existing sticker.
+// You may use this to reshare an existing sticker without
+// reuploading it.
+//
+// chatID is where to send it, fileID is the ID of the sticker
+// already uploaded.
+func NewStickerShare(chatID int64, fileID string) StickerConfig {
+	return StickerConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			FileID:      fileID,
+			UseExisting: true,
+		},
+	}
+}
+
+// NewVideoUpload creates a new video uploader.
+//
+// chatID is where to send it, file is a string path to the file,
+// FileReader, or FileBytes.
+func NewVideoUpload(chatID int64, file interface{}) VideoConfig {
+	return VideoConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			File:        file,
+			UseExisting: false,
+		},
+	}
+}
+
+// NewVideoShare shares an existing video.
+// You may use this to reshare an existing video without reuploading it.
+//
+// chatID is where to send it, fileID is the ID of the video
+// already uploaded.
+func NewVideoShare(chatID int64, fileID string) VideoConfig {
+	return VideoConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			FileID:      fileID,
+			UseExisting: true,
+		},
+	}
+}
+
+// NewVoiceUpload creates a new voice uploader.
+//
+// chatID is where to send it, file is a string path to the file,
+// FileReader, or FileBytes.
+func NewVoiceUpload(chatID int64, file interface{}) VoiceConfig {
+	return VoiceConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			File:        file,
+			UseExisting: false,
+		},
+	}
+}
+
+// NewVoiceShare shares an existing voice.
+// You may use this to reshare an existing voice without reuploading it.
+//
+// chatID is where to send it, fileID is the ID of the video
+// already uploaded.
+func NewVoiceShare(chatID int64, fileID string) VoiceConfig {
+	return VoiceConfig{
+		BaseFile: BaseFile{
+			BaseChat:    BaseChat{ChatID: chatID},
+			FileID:      fileID,
+			UseExisting: true,
+		},
+	}
+}
+
+// NewContact allows you to send a shared contact.
+func NewContact(chatID int64, phoneNumber, firstName string) ContactConfig {
+	return ContactConfig{
+		BaseChat: BaseChat{
+			ChatID: chatID,
+		},
+		PhoneNumber: phoneNumber,
+		FirstName:   firstName,
+	}
+}
+
+// NewLocation shares your location.
+//
+// chatID is where to send it, latitude and longitude are coordinates.
+func NewLocation(chatID int64, latitude float64, longitude float64) LocationConfig {
+	return LocationConfig{
+		BaseChat: BaseChat{
+			ChatID: chatID,
+		},
+		Latitude:  latitude,
+		Longitude: longitude,
+	}
+}
+
+// NewVenue allows you to send a venue and its location.
+func NewVenue(chatID int64, title, address string, latitude, longitude float64) VenueConfig {
+	return VenueConfig{
+		BaseChat: BaseChat{
+			ChatID: chatID,
+		},
+		Title:     title,
+		Address:   address,
+		Latitude:  latitude,
+		Longitude: longitude,
+	}
+}
+
+// NewChatAction sets a chat action.
+// Actions last for 5 seconds, or until your next action.
+//
+// chatID is where to send it, action should be set via Chat constants.
+func NewChatAction(chatID int64, action string) ChatActionConfig {
+	return ChatActionConfig{
+		BaseChat: BaseChat{ChatID: chatID},
+		Action:   action,
+	}
+}
+
+// NewUserProfilePhotos gets user profile photos.
+//
+// userID is the ID of the user you wish to get profile photos from.
+func NewUserProfilePhotos(userID int) UserProfilePhotosConfig {
+	return UserProfilePhotosConfig{
+		UserID: userID,
+		Offset: 0,
+		Limit:  0,
+	}
+}
+
+// NewUpdate gets updates since the last Offset.
+//
+// offset is the last Update ID to include.
+// You likely want to set this to the last Update ID plus 1.
+func NewUpdate(offset int) UpdateConfig {
+	return UpdateConfig{
+		Offset:  offset,
+		Limit:   0,
+		Timeout: 0,
+	}
+}
+
+// NewWebhook creates a new webhook.
+//
+// link is the url parsable link you wish to get the updates.
+func NewWebhook(link string) WebhookConfig {
+	u, _ := url.Parse(link)
+
+	return WebhookConfig{
+		URL: u,
+	}
+}
+
+// NewWebhookWithCert creates a new webhook with a certificate.
+//
+// link is the url you wish to get webhooks,
+// file contains a string to a file, FileReader, or FileBytes.
+func NewWebhookWithCert(link string, file interface{}) WebhookConfig {
+	u, _ := url.Parse(link)
+
+	return WebhookConfig{
+		URL:         u,
+		Certificate: file,
+	}
+}
+
+// NewWebhookWithCert creates a new webhook with a certificate and max_connections.
+//
+// link is the url you wish to get webhooks,
+// file contains a string to a file, FileReader, or FileBytes.
+// maxConnections defines maximum number of connections from telegram to your server
+func NewWebhookWithCertAndMaxConnections(link string, file interface{}, maxConnections int) WebhookConfig {
+	u, _ := url.Parse(link)
+
+	return WebhookConfig{
+		URL:         u,
+		Certificate: file,
+		MaxConnections: maxConnections,
+	}
+}
+
+// NewInlineQueryResultArticle creates a new inline query article.
+func NewInlineQueryResultArticle(id, title, messageText string) InlineQueryResultArticle {
+	return InlineQueryResultArticle{
+		Type:  "article",
+		ID:    id,
+		Title: title,
+		InputMessageContent: InputTextMessageContent{
+			Text: messageText,
+		},
+	}
+}
+
+// NewInlineQueryResultArticleMarkdown creates a new inline query article with Markdown parsing.
+func NewInlineQueryResultArticleMarkdown(id, title, messageText string) InlineQueryResultArticle {
+	return InlineQueryResultArticle{
+		Type:  "article",
+		ID:    id,
+		Title: title,
+		InputMessageContent: InputTextMessageContent{
+			Text:      messageText,
+			ParseMode: "Markdown",
+		},
+	}
+}
+
+// NewInlineQueryResultArticleHTML creates a new inline query article with HTML parsing.
+func NewInlineQueryResultArticleHTML(id, title, messageText string) InlineQueryResultArticle {
+	return InlineQueryResultArticle{
+		Type:  "article",
+		ID:    id,
+		Title: title,
+		InputMessageContent: InputTextMessageContent{
+			Text:      messageText,
+			ParseMode: "HTML",
+		},
+	}
+}
+
+// NewInlineQueryResultGIF creates a new inline query GIF.
+func NewInlineQueryResultGIF(id, url string) InlineQueryResultGIF {
+	return InlineQueryResultGIF{
+		Type: "gif",
+		ID:   id,
+		URL:  url,
+	}
+}
+
+// NewInlineQueryResultMPEG4GIF creates a new inline query MPEG4 GIF.
+func NewInlineQueryResultMPEG4GIF(id, url string) InlineQueryResultMPEG4GIF {
+	return InlineQueryResultMPEG4GIF{
+		Type: "mpeg4_gif",
+		ID:   id,
+		URL:  url,
+	}
+}
+
+// NewInlineQueryResultPhoto creates a new inline query photo.
+func NewInlineQueryResultPhoto(id, url string) InlineQueryResultPhoto {
+	return InlineQueryResultPhoto{
+		Type: "photo",
+		ID:   id,
+		URL:  url,
+	}
+}
+
+// NewInlineQueryResultPhotoWithThumb creates a new inline query photo.
+func NewInlineQueryResultPhotoWithThumb(id, url, thumb string) InlineQueryResultPhoto {
+	return InlineQueryResultPhoto{
+		Type:     "photo",
+		ID:       id,
+		URL:      url,
+		ThumbURL: thumb,
+	}
+}
+
+// NewInlineQueryResultVideo creates a new inline query video.
+func NewInlineQueryResultVideo(id, url string) InlineQueryResultVideo {
+	return InlineQueryResultVideo{
+		Type: "video",
+		ID:   id,
+		URL:  url,
+	}
+}
+
+// NewInlineQueryResultAudio creates a new inline query audio.
+func NewInlineQueryResultAudio(id, url, title string) InlineQueryResultAudio {
+	return InlineQueryResultAudio{
+		Type:  "audio",
+		ID:    id,
+		URL:   url,
+		Title: title,
+	}
+}
+
+// NewInlineQueryResultVoice creates a new inline query voice.
+func NewInlineQueryResultVoice(id, url, title string) InlineQueryResultVoice {
+	return InlineQueryResultVoice{
+		Type:  "voice",
+		ID:    id,
+		URL:   url,
+		Title: title,
+	}
+}
+
+// NewInlineQueryResultDocument creates a new inline query document.
+func NewInlineQueryResultDocument(id, url, title, mimeType string) InlineQueryResultDocument {
+	return InlineQueryResultDocument{
+		Type:     "document",
+		ID:       id,
+		URL:      url,
+		Title:    title,
+		MimeType: mimeType,
+	}
+}
+
+// NewInlineQueryResultLocation creates a new inline query location.
+func NewInlineQueryResultLocation(id, title string, latitude, longitude float64) InlineQueryResultLocation {
+	return InlineQueryResultLocation{
+		Type:      "location",
+		ID:        id,
+		Title:     title,
+		Latitude:  latitude,
+		Longitude: longitude,
+	}
+}
+
+// NewEditMessageText allows you to edit the text of a message.
+func NewEditMessageText(chatID int64, messageID int, text string) EditMessageTextConfig {
+	return EditMessageTextConfig{
+		BaseEdit: BaseEdit{
+			ChatID:    chatID,
+			MessageID: messageID,
+		},
+		Text: text,
+	}
+}
+
+// NewEditMessageCaption allows you to edit the caption of a message.
+func NewEditMessageCaption(chatID int64, messageID int, caption string) EditMessageCaptionConfig {
+	return EditMessageCaptionConfig{
+		BaseEdit: BaseEdit{
+			ChatID:    chatID,
+			MessageID: messageID,
+		},
+		Caption: caption,
+	}
+}
+
+// NewEditMessageReplyMarkup allows you to edit the inline
+// keyboard markup.
+func NewEditMessageReplyMarkup(chatID int64, messageID int, replyMarkup InlineKeyboardMarkup) EditMessageReplyMarkupConfig {
+	return EditMessageReplyMarkupConfig{
+		BaseEdit: BaseEdit{
+			ChatID:      chatID,
+			MessageID:   messageID,
+			ReplyMarkup: &replyMarkup,
+		},
+	}
+}
+
+// NewHideKeyboard hides the keyboard, with the option for being selective
+// or hiding for everyone.
+func NewHideKeyboard(selective bool) ReplyKeyboardHide {
+	log.Println("NewHideKeyboard is deprecated, please use NewRemoveKeyboard")
+
+	return ReplyKeyboardHide{
+		HideKeyboard: true,
+		Selective:    selective,
+	}
+}
+
+// NewRemoveKeyboard hides the keyboard, with the option for being selective
+// or hiding for everyone.
+func NewRemoveKeyboard(selective bool) ReplyKeyboardRemove {
+	return ReplyKeyboardRemove{
+		RemoveKeyboard: true,
+		Selective:      selective,
+	}
+}
+
+// NewKeyboardButton creates a regular keyboard button.
+func NewKeyboardButton(text string) KeyboardButton {
+	return KeyboardButton{
+		Text: text,
+	}
+}
+
+// NewKeyboardButtonContact creates a keyboard button that requests
+// user contact information upon click.
+func NewKeyboardButtonContact(text string) KeyboardButton {
+	return KeyboardButton{
+		Text:           text,
+		RequestContact: true,
+	}
+}
+
+// NewKeyboardButtonLocation creates a keyboard button that requests
+// user location information upon click.
+func NewKeyboardButtonLocation(text string) KeyboardButton {
+	return KeyboardButton{
+		Text:            text,
+		RequestLocation: true,
+	}
+}
+
+// NewKeyboardButtonRow creates a row of keyboard buttons.
+func NewKeyboardButtonRow(buttons ...KeyboardButton) []KeyboardButton {
+	var row []KeyboardButton
+
+	row = append(row, buttons...)
+
+	return row
+}
+
+// NewReplyKeyboard creates a new regular keyboard with sane defaults.
+func NewReplyKeyboard(rows ...[]KeyboardButton) ReplyKeyboardMarkup {
+	var keyboard [][]KeyboardButton
+
+	keyboard = append(keyboard, rows...)
+
+	return ReplyKeyboardMarkup{
+		ResizeKeyboard: true,
+		Keyboard:       keyboard,
+	}
+}
+
+// NewInlineKeyboardButtonData creates an inline keyboard button with text
+// and data for a callback.
+func NewInlineKeyboardButtonData(text, data string) InlineKeyboardButton {
+	return InlineKeyboardButton{
+		Text:         text,
+		CallbackData: &data,
+	}
+}
+
+// NewInlineKeyboardButtonURL creates an inline keyboard button with text
+// which goes to a URL.
+func NewInlineKeyboardButtonURL(text, url string) InlineKeyboardButton {
+	return InlineKeyboardButton{
+		Text: text,
+		URL:  &url,
+	}
+}
+
+// NewInlineKeyboardButtonSwitch creates an inline keyboard button with
+// text which allows the user to switch to a chat or return to a chat.
+func NewInlineKeyboardButtonSwitch(text, sw string) InlineKeyboardButton {
+	return InlineKeyboardButton{
+		Text:              text,
+		SwitchInlineQuery: &sw,
+	}
+}
+
+// NewInlineKeyboardRow creates an inline keyboard row with buttons.
+func NewInlineKeyboardRow(buttons ...InlineKeyboardButton) []InlineKeyboardButton {
+	var row []InlineKeyboardButton
+
+	row = append(row, buttons...)
+
+	return row
+}
+
+// NewInlineKeyboardMarkup creates a new inline keyboard.
+func NewInlineKeyboardMarkup(rows ...[]InlineKeyboardButton) InlineKeyboardMarkup {
+	var keyboard [][]InlineKeyboardButton
+
+	keyboard = append(keyboard, rows...)
+
+	return InlineKeyboardMarkup{
+		InlineKeyboard: keyboard,
+	}
+}
+
+// NewCallback creates a new callback message.
+func NewCallback(id, text string) CallbackConfig {
+	return CallbackConfig{
+		CallbackQueryID: id,
+		Text:            text,
+		ShowAlert:       false,
+	}
+}
+
+// NewCallbackWithAlert creates a new callback message that alerts
+// the user.
+func NewCallbackWithAlert(id, text string) CallbackConfig {
+	return CallbackConfig{
+		CallbackQueryID: id,
+		Text:            text,
+		ShowAlert:       true,
+	}
+}

vendor/github.com/go-telegram-bot-api/telegram-bot-api/types.go

@@ -0,0 +1,637 @@
+package tgbotapi
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// APIResponse is a response from the Telegram API with the result
+// stored raw.
+type APIResponse struct {
+	Ok          bool                `json:"ok"`
+	Result      json.RawMessage     `json:"result"`
+	ErrorCode   int                 `json:"error_code"`
+	Description string              `json:"description"`
+	Parameters  *ResponseParameters `json:"parameters"`
+}
+
+// ResponseParameters are various errors that can be returned in APIResponse.
+type ResponseParameters struct {
+	MigrateToChatID int64 `json:"migrate_to_chat_id"` // optional
+	RetryAfter      int   `json:"retry_after"`        // optional
+}
+
+// Update is an update response, from GetUpdates.
+type Update struct {
+	UpdateID           int                 `json:"update_id"`
+	Message            *Message            `json:"message"`
+	EditedMessage      *Message            `json:"edited_message"`
+	ChannelPost        *Message            `json:"channel_post"`
+	EditedChannelPost  *Message            `json:"edited_channel_post"`
+	InlineQuery        *InlineQuery        `json:"inline_query"`
+	ChosenInlineResult *ChosenInlineResult `json:"chosen_inline_result"`
+	CallbackQuery      *CallbackQuery      `json:"callback_query"`
+}
+
+// UpdatesChannel is the channel for getting updates.
+type UpdatesChannel <-chan Update
+
+// Clear discards all unprocessed incoming updates.
+func (ch UpdatesChannel) Clear() {
+	for len(ch) != 0 {
+		<-ch
+	}
+}
+
+// User is a user on Telegram.
+type User struct {
+	ID        int    `json:"id"`
+	FirstName string `json:"first_name"`
+	LastName  string `json:"last_name"` // optional
+	UserName  string `json:"username"`  // optional
+}
+
+// String displays a simple text version of a user.
+//
+// It is normally a user's username, but falls back to a first/last
+// name as available.
+func (u *User) String() string {
+	if u.UserName != "" {
+		return u.UserName
+	}
+
+	name := u.FirstName
+	if u.LastName != "" {
+		name += " " + u.LastName
+	}
+
+	return name
+}
+
+// GroupChat is a group chat.
+type GroupChat struct {
+	ID    int    `json:"id"`
+	Title string `json:"title"`
+}
+
+// Chat contains information about the place a message was sent.
+type Chat struct {
+	ID                  int64  `json:"id"`
+	Type                string `json:"type"`
+	Title               string `json:"title"`                          // optional
+	UserName            string `json:"username"`                       // optional
+	FirstName           string `json:"first_name"`                     // optional
+	LastName            string `json:"last_name"`                      // optional
+	AllMembersAreAdmins bool   `json:"all_members_are_administrators"` // optional
+}
+
+// IsPrivate returns if the Chat is a private conversation.
+func (c Chat) IsPrivate() bool {
+	return c.Type == "private"
+}
+
+// IsGroup returns if the Chat is a group.
+func (c Chat) IsGroup() bool {
+	return c.Type == "group"
+}
+
+// IsSuperGroup returns if the Chat is a supergroup.
+func (c Chat) IsSuperGroup() bool {
+	return c.Type == "supergroup"
+}
+
+// IsChannel returns if the Chat is a channel.
+func (c Chat) IsChannel() bool {
+	return c.Type == "channel"
+}
+
+// ChatConfig returns a ChatConfig struct for chat related methods.
+func (c Chat) ChatConfig() ChatConfig {
+	return ChatConfig{ChatID: c.ID}
+}
+
+// Message is returned by almost every request, and contains data about
+// almost anything.
+type Message struct {
+	MessageID             int              `json:"message_id"`
+	From                  *User            `json:"from"` // optional
+	Date                  int              `json:"date"`
+	Chat                  *Chat            `json:"chat"`
+	ForwardFrom           *User            `json:"forward_from"`            // optional
+	ForwardFromChat       *Chat            `json:"forward_from_chat"`       // optional
+	ForwardFromMessageID  int              `json:"forward_from_message_id"` // optional
+	ForwardDate           int              `json:"forward_date"`            // optional
+	ReplyToMessage        *Message         `json:"reply_to_message"`        // optional
+	EditDate              int              `json:"edit_date"`               // optional
+	Text                  string           `json:"text"`                    // optional
+	Entities              *[]MessageEntity `json:"entities"`                // optional
+	Audio                 *Audio           `json:"audio"`                   // optional
+	Document              *Document        `json:"document"`                // optional
+	Game                  *Game            `json:"game"`                    // optional
+	Photo                 *[]PhotoSize     `json:"photo"`                   // optional
+	Sticker               *Sticker         `json:"sticker"`                 // optional
+	Video                 *Video           `json:"video"`                   // optional
+	Voice                 *Voice           `json:"voice"`                   // optional
+	Caption               string           `json:"caption"`                 // optional
+	Contact               *Contact         `json:"contact"`                 // optional
+	Location              *Location        `json:"location"`                // optional
+	Venue                 *Venue           `json:"venue"`                   // optional
+	NewChatMember         *User            `json:"new_chat_member"`         // optional
+	LeftChatMember        *User            `json:"left_chat_member"`        // optional
+	NewChatTitle          string           `json:"new_chat_title"`          // optional
+	NewChatPhoto          *[]PhotoSize     `json:"new_chat_photo"`          // optional
+	DeleteChatPhoto       bool             `json:"delete_chat_photo"`       // optional
+	GroupChatCreated      bool             `json:"group_chat_created"`      // optional
+	SuperGroupChatCreated bool             `json:"supergroup_chat_created"` // optional
+	ChannelChatCreated    bool             `json:"channel_chat_created"`    // optional
+	MigrateToChatID       int64            `json:"migrate_to_chat_id"`      // optional
+	MigrateFromChatID     int64            `json:"migrate_from_chat_id"`    // optional
+	PinnedMessage         *Message         `json:"pinned_message"`          // optional
+}
+
+// Time converts the message timestamp into a Time.
+func (m *Message) Time() time.Time {
+	return time.Unix(int64(m.Date), 0)
+}
+
+// IsCommand returns true if message starts with '/'.
+func (m *Message) IsCommand() bool {
+	return m.Text != "" && m.Text[0] == '/'
+}
+
+// Command checks if the message was a command and if it was, returns the
+// command. If the Message was not a command, it returns an empty string.
+//
+// If the command contains the at bot syntax, it removes the bot name.
+func (m *Message) Command() string {
+	if !m.IsCommand() {
+		return ""
+	}
+
+	command := strings.SplitN(m.Text, " ", 2)[0][1:]
+
+	if i := strings.Index(command, "@"); i != -1 {
+		command = command[:i]
+	}
+
+	return command
+}
+
+// CommandArguments checks if the message was a command and if it was,
+// returns all text after the command name. If the Message was not a
+// command, it returns an empty string.
+func (m *Message) CommandArguments() string {
+	if !m.IsCommand() {
+		return ""
+	}
+
+	split := strings.SplitN(m.Text, " ", 2)
+	if len(split) != 2 {
+		return ""
+	}
+
+	return strings.SplitN(m.Text, " ", 2)[1]
+}
+
+// MessageEntity contains information about data in a Message.
+type MessageEntity struct {
+	Type   string `json:"type"`
+	Offset int    `json:"offset"`
+	Length int    `json:"length"`
+	URL    string `json:"url"`  // optional
+	User   *User  `json:"user"` // optional
+}
+
+// ParseURL attempts to parse a URL contained within a MessageEntity.
+func (entity MessageEntity) ParseURL() (*url.URL, error) {
+	if entity.URL == "" {
+		return nil, errors.New(ErrBadURL)
+	}
+
+	return url.Parse(entity.URL)
+}
+
+// PhotoSize contains information about photos.
+type PhotoSize struct {
+	FileID   string `json:"file_id"`
+	Width    int    `json:"width"`
+	Height   int    `json:"height"`
+	FileSize int    `json:"file_size"` // optional
+}
+
+// Audio contains information about audio.
+type Audio struct {
+	FileID    string `json:"file_id"`
+	Duration  int    `json:"duration"`
+	Performer string `json:"performer"` // optional
+	Title     string `json:"title"`     // optional
+	MimeType  string `json:"mime_type"` // optional
+	FileSize  int    `json:"file_size"` // optional
+}
+
+// Document contains information about a document.
+type Document struct {
+	FileID    string     `json:"file_id"`
+	Thumbnail *PhotoSize `json:"thumb"`     // optional
+	FileName  string     `json:"file_name"` // optional
+	MimeType  string     `json:"mime_type"` // optional
+	FileSize  int        `json:"file_size"` // optional
+}
+
+// Sticker contains information about a sticker.
+type Sticker struct {
+	FileID    string     `json:"file_id"`
+	Width     int        `json:"width"`
+	Height    int        `json:"height"`
+	Thumbnail *PhotoSize `json:"thumb"`     // optional
+	Emoji     string     `json:"emoji"`     // optional
+	FileSize  int        `json:"file_size"` // optional
+}
+
+// Video contains information about a video.
+type Video struct {
+	FileID    string     `json:"file_id"`
+	Width     int        `json:"width"`
+	Height    int        `json:"height"`
+	Duration  int        `json:"duration"`
+	Thumbnail *PhotoSize `json:"thumb"`     // optional
+	MimeType  string     `json:"mime_type"` // optional
+	FileSize  int        `json:"file_size"` // optional
+}
+
+// Voice contains information about a voice.
+type Voice struct {
+	FileID   string `json:"file_id"`
+	Duration int    `json:"duration"`
+	MimeType string `json:"mime_type"` // optional
+	FileSize int    `json:"file_size"` // optional
+}
+
+// Contact contains information about a contact.
+//
+// Note that LastName and UserID may be empty.
+type Contact struct {
+	PhoneNumber string `json:"phone_number"`
+	FirstName   string `json:"first_name"`
+	LastName    string `json:"last_name"` // optional
+	UserID      int    `json:"user_id"`   // optional
+}
+
+// Location contains information about a place.
+type Location struct {
+	Longitude float64 `json:"longitude"`
+	Latitude  float64 `json:"latitude"`
+}
+
+// Venue contains information about a venue, including its Location.
+type Venue struct {
+	Location     Location `json:"location"`
+	Title        string   `json:"title"`
+	Address      string   `json:"address"`
+	FoursquareID string   `json:"foursquare_id"` // optional
+}
+
+// UserProfilePhotos contains a set of user profile photos.
+type UserProfilePhotos struct {
+	TotalCount int           `json:"total_count"`
+	Photos     [][]PhotoSize `json:"photos"`
+}
+
+// File contains information about a file to download from Telegram.
+type File struct {
+	FileID   string `json:"file_id"`
+	FileSize int    `json:"file_size"` // optional
+	FilePath string `json:"file_path"` // optional
+}
+
+// Link returns a full path to the download URL for a File.
+//
+// It requires the Bot Token to create the link.
+func (f *File) Link(token string) string {
+	return fmt.Sprintf(FileEndpoint, token, f.FilePath)
+}
+
+// ReplyKeyboardMarkup allows the Bot to set a custom keyboard.
+type ReplyKeyboardMarkup struct {
+	Keyboard        [][]KeyboardButton `json:"keyboard"`
+	ResizeKeyboard  bool               `json:"resize_keyboard"`   // optional
+	OneTimeKeyboard bool               `json:"one_time_keyboard"` // optional
+	Selective       bool               `json:"selective"`         // optional
+}
+
+// KeyboardButton is a button within a custom keyboard.
+type KeyboardButton struct {
+	Text            string `json:"text"`
+	RequestContact  bool   `json:"request_contact"`
+	RequestLocation bool   `json:"request_location"`
+}
+
+// ReplyKeyboardHide allows the Bot to hide a custom keyboard.
+type ReplyKeyboardHide struct {
+	HideKeyboard bool `json:"hide_keyboard"`
+	Selective    bool `json:"selective"` // optional
+}
+
+// ReplyKeyboardRemove allows the Bot to hide a custom keyboard.
+type ReplyKeyboardRemove struct {
+	RemoveKeyboard bool `json:"remove_keyboard"`
+	Selective      bool `json:"selective"`
+}
+
+// InlineKeyboardMarkup is a custom keyboard presented for an inline bot.
+type InlineKeyboardMarkup struct {
+	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
+}
+
+// InlineKeyboardButton is a button within a custom keyboard for
+// inline query responses.
+//
+// Note that some values are references as even an empty string
+// will change behavior.
+//
+// CallbackGame, if set, MUST be first button in first row.
+type InlineKeyboardButton struct {
+	Text                         string        `json:"text"`
+	URL                          *string       `json:"url,omitempty"`                              // optional
+	CallbackData                 *string       `json:"callback_data,omitempty"`                    // optional
+	SwitchInlineQuery            *string       `json:"switch_inline_query,omitempty"`              // optional
+	SwitchInlineQueryCurrentChat *string       `json:"switch_inline_query_current_chat,omitempty"` // optional
+	CallbackGame                 *CallbackGame `json:"callback_game,omitempty"`                    // optional
+}
+
+// CallbackQuery is data sent when a keyboard button with callback data
+// is clicked.
+type CallbackQuery struct {
+	ID              string   `json:"id"`
+	From            *User    `json:"from"`
+	Message         *Message `json:"message"`           // optional
+	InlineMessageID string   `json:"inline_message_id"` // optional
+	ChatInstance    string   `json:"chat_instance"`
+	Data            string   `json:"data"`            // optional
+	GameShortName   string   `json:"game_short_name"` // optional
+}
+
+// ForceReply allows the Bot to have users directly reply to it without
+// additional interaction.
+type ForceReply struct {
+	ForceReply bool `json:"force_reply"`
+	Selective  bool `json:"selective"` // optional
+}
+
+// ChatMember is information about a member in a chat.
+type ChatMember struct {
+	User   *User  `json:"user"`
+	Status string `json:"status"`
+}
+
+// IsCreator returns if the ChatMember was the creator of the chat.
+func (chat ChatMember) IsCreator() bool { return chat.Status == "creator" }
+
+// IsAdministrator returns if the ChatMember is a chat administrator.
+func (chat ChatMember) IsAdministrator() bool { return chat.Status == "administrator" }
+
+// IsMember returns if the ChatMember is a current member of the chat.
+func (chat ChatMember) IsMember() bool { return chat.Status == "member" }
+
+// HasLeft returns if the ChatMember left the chat.
+func (chat ChatMember) HasLeft() bool { return chat.Status == "left" }
+
+// WasKicked returns if the ChatMember was kicked from the chat.
+func (chat ChatMember) WasKicked() bool { return chat.Status == "kicked" }
+
+// Game is a game within Telegram.
+type Game struct {
+	Title        string          `json:"title"`
+	Description  string          `json:"description"`
+	Photo        []PhotoSize     `json:"photo"`
+	Text         string          `json:"text"`
+	TextEntities []MessageEntity `json:"text_entities"`
+	Animation    Animation       `json:"animation"`
+}
+
+// Animation is a GIF animation demonstrating the game.
+type Animation struct {
+	FileID   string    `json:"file_id"`
+	Thumb    PhotoSize `json:"thumb"`
+	FileName string    `json:"file_name"`
+	MimeType string    `json:"mime_type"`
+	FileSize int       `json:"file_size"`
+}
+
+// GameHighScore is a user's score and position on the leaderboard.
+type GameHighScore struct {
+	Position int  `json:"position"`
+	User     User `json:"user"`
+	Score    int  `json:"score"`
+}
+
+// CallbackGame is for starting a game in an inline keyboard button.
+type CallbackGame struct{}
+
+// WebhookInfo is information about a currently set webhook.
+type WebhookInfo struct {
+	URL                  string `json:"url"`
+	HasCustomCertificate bool   `json:"has_custom_certificate"`
+	PendingUpdateCount   int    `json:"pending_update_count"`
+	LastErrorDate        int    `json:"last_error_date"`    // optional
+	LastErrorMessage     string `json:"last_error_message"` // optional
+}
+
+// IsSet returns true if a webhook is currently set.
+func (info WebhookInfo) IsSet() bool {
+	return info.URL != ""
+}
+
+// InlineQuery is a Query from Telegram for an inline request.
+type InlineQuery struct {
+	ID       string    `json:"id"`
+	From     *User     `json:"from"`
+	Location *Location `json:"location"` // optional
+	Query    string    `json:"query"`
+	Offset   string    `json:"offset"`
+}
+
+// InlineQueryResultArticle is an inline query response article.
+type InlineQueryResultArticle struct {
+	Type                string                `json:"type"`                            // required
+	ID                  string                `json:"id"`                              // required
+	Title               string                `json:"title"`                           // required
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"` // required
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	URL                 string                `json:"url"`
+	HideURL             bool                  `json:"hide_url"`
+	Description         string                `json:"description"`
+	ThumbURL            string                `json:"thumb_url"`
+	ThumbWidth          int                   `json:"thumb_width"`
+	ThumbHeight         int                   `json:"thumb_height"`
+}
+
+// InlineQueryResultPhoto is an inline query response photo.
+type InlineQueryResultPhoto struct {
+	Type                string                `json:"type"`      // required
+	ID                  string                `json:"id"`        // required
+	URL                 string                `json:"photo_url"` // required
+	MimeType            string                `json:"mime_type"`
+	Width               int                   `json:"photo_width"`
+	Height              int                   `json:"photo_height"`
+	ThumbURL            string                `json:"thumb_url"`
+	Title               string                `json:"title"`
+	Description         string                `json:"description"`
+	Caption             string                `json:"caption"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
+}
+
+// InlineQueryResultGIF is an inline query response GIF.
+type InlineQueryResultGIF struct {
+	Type                string                `json:"type"`    // required
+	ID                  string                `json:"id"`      // required
+	URL                 string                `json:"gif_url"` // required
+	Width               int                   `json:"gif_width"`
+	Height              int                   `json:"gif_height"`
+	ThumbURL            string                `json:"thumb_url"`
+	Title               string                `json:"title"`
+	Caption             string                `json:"caption"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
+}
+
+// InlineQueryResultMPEG4GIF is an inline query response MPEG4 GIF.
+type InlineQueryResultMPEG4GIF struct {
+	Type                string                `json:"type"`      // required
+	ID                  string                `json:"id"`        // required
+	URL                 string                `json:"mpeg4_url"` // required
+	Width               int                   `json:"mpeg4_width"`
+	Height              int                   `json:"mpeg4_height"`
+	ThumbURL            string                `json:"thumb_url"`
+	Title               string                `json:"title"`
+	Caption             string                `json:"caption"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
+}
+
+// InlineQueryResultVideo is an inline query response video.
+type InlineQueryResultVideo struct {
+	Type                string                `json:"type"`      // required
+	ID                  string                `json:"id"`        // required
+	URL                 string                `json:"video_url"` // required
+	MimeType            string                `json:"mime_type"` // required
+	ThumbURL            string                `json:"thumb_url"`
+	Title               string                `json:"title"`
+	Caption             string                `json:"caption"`
+	Width               int                   `json:"video_width"`
+	Height              int                   `json:"video_height"`
+	Duration            int                   `json:"video_duration"`
+	Description         string                `json:"description"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
+}
+
+// InlineQueryResultAudio is an inline query response audio.
+type InlineQueryResultAudio struct {
+	Type                string                `json:"type"`      // required
+	ID                  string                `json:"id"`        // required
+	URL                 string                `json:"audio_url"` // required
+	Title               string                `json:"title"`     // required
+	Caption             string                `json:"caption"`
+	Performer           string                `json:"performer"`
+	Duration            int                   `json:"audio_duration"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
+}
+
+// InlineQueryResultVoice is an inline query response voice.
+type InlineQueryResultVoice struct {
+	Type                string                `json:"type"`      // required
+	ID                  string                `json:"id"`        // required
+	URL                 string                `json:"voice_url"` // required
+	Title               string                `json:"title"`     // required
+	Caption             string                `json:"caption"`
+	Duration            int                   `json:"voice_duration"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
+}
+
+// InlineQueryResultDocument is an inline query response document.
+type InlineQueryResultDocument struct {
+	Type                string                `json:"type"`  // required
+	ID                  string                `json:"id"`    // required
+	Title               string                `json:"title"` // required
+	Caption             string                `json:"caption"`
+	URL                 string                `json:"document_url"` // required
+	MimeType            string                `json:"mime_type"`    // required
+	Description         string                `json:"description"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
+	ThumbURL            string                `json:"thumb_url"`
+	ThumbWidth          int                   `json:"thumb_width"`
+	ThumbHeight         int                   `json:"thumb_height"`
+}
+
+// InlineQueryResultLocation is an inline query response location.
+type InlineQueryResultLocation struct {
+	Type                string                `json:"type"`      // required
+	ID                  string                `json:"id"`        // required
+	Latitude            float64               `json:"latitude"`  // required
+	Longitude           float64               `json:"longitude"` // required
+	Title               string                `json:"title"`     // required
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
+	ThumbURL            string                `json:"thumb_url"`
+	ThumbWidth          int                   `json:"thumb_width"`
+	ThumbHeight         int                   `json:"thumb_height"`
+}
+
+// InlineQueryResultGame is an inline query response game.
+type InlineQueryResultGame struct {
+	Type          string                `json:"type"`
+	ID            string                `json:"id"`
+	GameShortName string                `json:"game_short_name"`
+	ReplyMarkup   *InlineKeyboardMarkup `json:"reply_markup"`
+}
+
+// ChosenInlineResult is an inline query result chosen by a User
+type ChosenInlineResult struct {
+	ResultID        string    `json:"result_id"`
+	From            *User     `json:"from"`
+	Location        *Location `json:"location"`
+	InlineMessageID string    `json:"inline_message_id"`
+	Query           string    `json:"query"`
+}
+
+// InputTextMessageContent contains text for displaying
+// as an inline query result.
+type InputTextMessageContent struct {
+	Text                  string `json:"message_text"`
+	ParseMode             string `json:"parse_mode"`
+	DisableWebPagePreview bool   `json:"disable_web_page_preview"`
+}
+
+// InputLocationMessageContent contains a location for displaying
+// as an inline query result.
+type InputLocationMessageContent struct {
+	Latitude  float64 `json:"latitude"`
+	Longitude float64 `json:"longitude"`
+}
+
+// InputVenueMessageContent contains a venue for displaying
+// as an inline query result.
+type InputVenueMessageContent struct {
+	Latitude     float64 `json:"latitude"`
+	Longitude    float64 `json:"longitude"`
+	Title        string  `json:"title"`
+	Address      string  `json:"address"`
+	FoursquareID string  `json:"foursquare_id"`
+}
+
+// InputContactMessageContent contains a contact for displaying
+// as an inline query result.
+type InputContactMessageContent struct {
+	PhoneNumber string `json:"phone_number"`
+	FirstName   string `json:"first_name"`
+	LastName    string `json:"last_name"`
+}

vendor/github.com/mattermost/platform/einterfaces/account_migration.go

@@ -0,0 +1,20 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package einterfaces
+
+import "github.com/mattermost/platform/model"
+
+type AccountMigrationInterface interface {
+	MigrateToLdap(fromAuthService string, forignUserFieldNameToMatch string) *model.AppError
+}
+
+var theAccountMigrationInterface AccountMigrationInterface
+
+func RegisterAccountMigrationInterface(newInterface AccountMigrationInterface) {
+	theAccountMigrationInterface = newInterface
+}
+
+func GetAccountMigrationInterface() AccountMigrationInterface {
+	return theAccountMigrationInterface
+}

vendor/github.com/mattermost/platform/einterfaces/cluster.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package einterfaces
+
+import (
+	"github.com/mattermost/platform/model"
+)
+
+type ClusterInterface interface {
+	StartInterNodeCommunication()
+	StopInterNodeCommunication()
+	GetClusterInfos() []*model.ClusterInfo
+	GetClusterStats() ([]*model.ClusterStats, *model.AppError)
+	RemoveAllSessionsForUserId(userId string)
+	InvalidateCacheForUser(userId string)
+	InvalidateCacheForChannel(channelId string)
+	InvalidateCacheForChannelPosts(channelId string)
+	Publish(event *model.WebSocketEvent)
+	UpdateStatus(status *model.Status)
+	GetLogs() ([]string, *model.AppError)
+	GetClusterId() string
+	ConfigChanged(previousConfig *model.Config, newConfig *model.Config, sendToOtherServer bool) *model.AppError
+	InvalidateAllCaches() *model.AppError
+}
+
+var theClusterInterface ClusterInterface
+
+func RegisterClusterInterface(newInterface ClusterInterface) {
+	theClusterInterface = newInterface
+}
+
+func GetClusterInterface() ClusterInterface {
+	return theClusterInterface
+}

vendor/github.com/mattermost/platform/einterfaces/ldap.go

@@ -15,6 +15,9 @@ type LdapInterface interface {
 	ValidateFilter(filter string) *model.AppError
 	Syncronize() *model.AppError
 	StartLdapSyncJob()
+	SyncNow()
+	RunTest() *model.AppError
+	GetAllLdapUsers() ([]*model.User, *model.AppError)
 }
 
 var theLdapInterface LdapInterface

vendor/github.com/mattermost/platform/einterfaces/metrics.go

@@ -0,0 +1,41 @@
+// Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package einterfaces
+
+type MetricsInterface interface {
+	StartServer()
+	StopServer()
+
+	IncrementPostCreate()
+	IncrementPostSentEmail()
+	IncrementPostSentPush()
+	IncrementPostBroadcast()
+	IncrementPostFileAttachment(count int)
+
+	IncrementHttpRequest()
+	IncrementHttpError()
+	ObserveHttpRequestDuration(elapsed float64)
+
+	IncrementLogin()
+	IncrementLoginFail()
+
+	IncrementEtagHitCounter(route string)
+	IncrementEtagMissCounter(route string)
+
+	IncrementMemCacheHitCounter(cacheName string)
+	IncrementMemCacheMissCounter(cacheName string)
+
+	AddMemCacheHitCounter(cacheName string, amount float64)
+	AddMemCacheMissCounter(cacheName string, amount float64)
+}
+
+var theMetricsInterface MetricsInterface
+
+func RegisterMetricsInterface(newInterface MetricsInterface) {
+	theMetricsInterface = newInterface
+}
+
+func GetMetricsInterface() MetricsInterface {
+	return theMetricsInterface
+}

vendor/github.com/mattermost/platform/einterfaces/mfa.go

@@ -8,7 +8,7 @@ import (
 )
 
 type MfaInterface interface {
-	GenerateQrCode(user *model.User) ([]byte, *model.AppError)
+	GenerateSecret(user *model.User) (string, []byte, *model.AppError)
 	Activate(user *model.User, token string) *model.AppError
 	Deactivate(userId string) *model.AppError
 	ValidateToken(secret, token string) (bool, *model.AppError)

vendor/github.com/mattermost/platform/model/access.go

@@ -15,10 +15,12 @@ const (
 )
 
 type AccessData struct {
-	AuthCode     string `json:"auth_code"`
+	ClientId     string `json:"client_id"`
+	UserId       string `json:"user_id"`
 	Token        string `json:"token"`
 	RefreshToken string `json:"refresh_token"`
 	RedirectUri  string `json:"redirect_uri"`
+	ExpiresAt    int64  `json:"expires_at"`
 }
 
 type AccessResponse struct {
@@ -33,8 +35,12 @@ type AccessResponse struct {
 // correctly.
 func (ad *AccessData) IsValid() *AppError {
 
-	if len(ad.AuthCode) == 0 || len(ad.AuthCode) > 128 {
+	if len(ad.ClientId) == 0 || len(ad.ClientId) > 26 {
-		return NewLocAppError("AccessData.IsValid", "model.access.is_valid.auth_code.app_error", nil, "")
+		return NewLocAppError("AccessData.IsValid", "model.access.is_valid.client_id.app_error", nil, "")
+	}
+
+	if len(ad.UserId) == 0 || len(ad.UserId) > 26 {
+		return NewLocAppError("AccessData.IsValid", "model.access.is_valid.user_id.app_error", nil, "")
 	}
 
 	if len(ad.Token) != 26 {
@@ -52,6 +58,19 @@ func (ad *AccessData) IsValid() *AppError {
 	return nil
 }
 
+func (me *AccessData) IsExpired() bool {
+
+	if me.ExpiresAt <= 0 {
+		return false
+	}
+
+	if GetMillis() > me.ExpiresAt {
+		return true
+	}
+
+	return false
+}
+
 func (ad *AccessData) ToJson() string {
 	b, err := json.Marshal(ad)
 	if err != nil {

vendor/github.com/mattermost/platform/model/authorization.go

@@ -0,0 +1,372 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package model
+
+type Permission struct {
+	Id          string `json:"id"`
+	Name        string `json:"name"`
+	Description string `json:"description"`
+}
+
+type Role struct {
+	Id          string   `json:"id"`
+	Name        string   `json:"name"`
+	Description string   `json:"description"`
+	Permissions []string `json:"permissions"`
+}
+
+var PERMISSION_INVITE_USER *Permission
+var PERMISSION_ADD_USER_TO_TEAM *Permission
+var PERMISSION_USE_SLASH_COMMANDS *Permission
+var PERMISSION_MANAGE_SLASH_COMMANDS *Permission
+var PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS *Permission
+var PERMISSION_CREATE_PUBLIC_CHANNEL *Permission
+var PERMISSION_CREATE_PRIVATE_CHANNEL *Permission
+var PERMISSION_MANAGE_PUBLIC_CHANNEL_MEMBERS *Permission
+var PERMISSION_MANAGE_PRIVATE_CHANNEL_MEMBERS *Permission
+var PERMISSION_ASSIGN_SYSTEM_ADMIN_ROLE *Permission
+var PERMISSION_MANAGE_ROLES *Permission
+var PERMISSION_CREATE_DIRECT_CHANNEL *Permission
+var PERMISSION_MANAGE_PUBLIC_CHANNEL_PROPERTIES *Permission
+var PERMISSION_MANAGE_PRIVATE_CHANNEL_PROPERTIES *Permission
+var PERMISSION_LIST_TEAM_CHANNELS *Permission
+var PERMISSION_JOIN_PUBLIC_CHANNELS *Permission
+var PERMISSION_DELETE_PUBLIC_CHANNEL *Permission
+var PERMISSION_DELETE_PRIVATE_CHANNEL *Permission
+var PERMISSION_EDIT_OTHER_USERS *Permission
+var PERMISSION_READ_CHANNEL *Permission
+var PERMISSION_PERMANENT_DELETE_USER *Permission
+var PERMISSION_UPLOAD_FILE *Permission
+var PERMISSION_GET_PUBLIC_LINK *Permission
+var PERMISSION_MANAGE_WEBHOOKS *Permission
+var PERMISSION_MANAGE_OTHERS_WEBHOOKS *Permission
+var PERMISSION_MANAGE_OAUTH *Permission
+var PERMISSION_MANAGE_SYSTEM_WIDE_OAUTH *Permission
+var PERMISSION_CREATE_POST *Permission
+var PERMISSION_EDIT_POST *Permission
+var PERMISSION_EDIT_OTHERS_POSTS *Permission
+var PERMISSION_REMOVE_USER_FROM_TEAM *Permission
+var PERMISSION_MANAGE_TEAM *Permission
+var PERMISSION_IMPORT_TEAM *Permission
+
+// General permission that encompases all system admin functions
+// in the future this could be broken up to allow access to some
+// admin functions but not others
+var PERMISSION_MANAGE_SYSTEM *Permission
+
+var ROLE_SYSTEM_USER *Role
+var ROLE_SYSTEM_ADMIN *Role
+
+var ROLE_TEAM_USER *Role
+var ROLE_TEAM_ADMIN *Role
+
+var ROLE_CHANNEL_USER *Role
+var ROLE_CHANNEL_ADMIN *Role
+var ROLE_CHANNEL_GUEST *Role
+
+var BuiltInRoles map[string]*Role
+
+func InitalizePermissions() {
+	PERMISSION_INVITE_USER = &Permission{
+		"invite_user",
+		"authentication.permissions.team_invite_user.name",
+		"authentication.permissions.team_invite_user.description",
+	}
+	PERMISSION_ADD_USER_TO_TEAM = &Permission{
+		"add_user_to_team",
+		"authentication.permissions.add_user_to_team.name",
+		"authentication.permissions.add_user_to_team.description",
+	}
+	PERMISSION_USE_SLASH_COMMANDS = &Permission{
+		"use_slash_commands",
+		"authentication.permissions.team_use_slash_commands.name",
+		"authentication.permissions.team_use_slash_commands.description",
+	}
+	PERMISSION_MANAGE_SLASH_COMMANDS = &Permission{
+		"manage_slash_commands",
+		"authentication.permissions.manage_slash_commands.name",
+		"authentication.permissions.manage_slash_commands.description",
+	}
+	PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS = &Permission{
+		"manage_others_slash_commands",
+		"authentication.permissions.manage_others_slash_commands.name",
+		"authentication.permissions.manage_others_slash_commands.description",
+	}
+	PERMISSION_CREATE_PUBLIC_CHANNEL = &Permission{
+		"create_public_channel",
+		"authentication.permissions.create_public_channel.name",
+		"authentication.permissions.create_public_channel.description",
+	}
+	PERMISSION_CREATE_PRIVATE_CHANNEL = &Permission{
+		"create_private_channel",
+		"authentication.permissions.create_private_channel.name",
+		"authentication.permissions.create_private_channel.description",
+	}
+	PERMISSION_MANAGE_PUBLIC_CHANNEL_MEMBERS = &Permission{
+		"manage_public_channel_members",
+		"authentication.permissions.manage_public_channel_members.name",
+		"authentication.permissions.manage_public_channel_members.description",
+	}
+	PERMISSION_MANAGE_PRIVATE_CHANNEL_MEMBERS = &Permission{
+		"manage_private_channel_members",
+		"authentication.permissions.manage_private_channel_members.name",
+		"authentication.permissions.manage_private_channel_members.description",
+	}
+	PERMISSION_ASSIGN_SYSTEM_ADMIN_ROLE = &Permission{
+		"assign_system_admin_role",
+		"authentication.permissions.assign_system_admin_role.name",
+		"authentication.permissions.assign_system_admin_role.description",
+	}
+	PERMISSION_MANAGE_ROLES = &Permission{
+		"manage_roles",
+		"authentication.permissions.manage_roles.name",
+		"authentication.permissions.manage_roles.description",
+	}
+	PERMISSION_MANAGE_SYSTEM = &Permission{
+		"manage_system",
+		"authentication.permissions.manage_system.name",
+		"authentication.permissions.manage_system.description",
+	}
+	PERMISSION_CREATE_DIRECT_CHANNEL = &Permission{
+		"create_direct_channel",
+		"authentication.permissions.create_direct_channel.name",
+		"authentication.permissions.create_direct_channel.description",
+	}
+	PERMISSION_MANAGE_PUBLIC_CHANNEL_PROPERTIES = &Permission{
+		"manage__publicchannel_properties",
+		"authentication.permissions.manage_public_channel_properties.name",
+		"authentication.permissions.manage_public_channel_properties.description",
+	}
+	PERMISSION_MANAGE_PRIVATE_CHANNEL_PROPERTIES = &Permission{
+		"manage_private_channel_properties",
+		"authentication.permissions.manage_private_channel_properties.name",
+		"authentication.permissions.manage_private_channel_properties.description",
+	}
+	PERMISSION_LIST_TEAM_CHANNELS = &Permission{
+		"list_team_channels",
+		"authentication.permissions.list_team_channels.name",
+		"authentication.permissions.list_team_channels.description",
+	}
+	PERMISSION_JOIN_PUBLIC_CHANNELS = &Permission{
+		"join_public_channels",
+		"authentication.permissions.join_public_channels.name",
+		"authentication.permissions.join_public_channels.description",
+	}
+	PERMISSION_DELETE_PUBLIC_CHANNEL = &Permission{
+		"delete_public_channel",
+		"authentication.permissions.delete_public_channel.name",
+		"authentication.permissions.delete_public_channel.description",
+	}
+	PERMISSION_DELETE_PRIVATE_CHANNEL = &Permission{
+		"delete_private_channel",
+		"authentication.permissions.delete_private_channel.name",
+		"authentication.permissions.delete_private_channel.description",
+	}
+	PERMISSION_EDIT_OTHER_USERS = &Permission{
+		"edit_other_users",
+		"authentication.permissions.edit_other_users.name",
+		"authentication.permissions.edit_other_users.description",
+	}
+	PERMISSION_READ_CHANNEL = &Permission{
+		"read_channel",
+		"authentication.permissions.read_channel.name",
+		"authentication.permissions.read_channel.description",
+	}
+	PERMISSION_PERMANENT_DELETE_USER = &Permission{
+		"permanent_delete_user",
+		"authentication.permissions.permanent_delete_user.name",
+		"authentication.permissions.permanent_delete_user.description",
+	}
+	PERMISSION_UPLOAD_FILE = &Permission{
+		"upload_file",
+		"authentication.permissions.upload_file.name",
+		"authentication.permissions.upload_file.description",
+	}
+	PERMISSION_GET_PUBLIC_LINK = &Permission{
+		"get_public_link",
+		"authentication.permissions.get_public_link.name",
+		"authentication.permissions.get_public_link.description",
+	}
+	PERMISSION_MANAGE_WEBHOOKS = &Permission{
+		"manage_webhooks",
+		"authentication.permissions.manage_webhooks.name",
+		"authentication.permissions.manage_webhooks.description",
+	}
+	PERMISSION_MANAGE_OTHERS_WEBHOOKS = &Permission{
+		"manage_others_webhooks",
+		"authentication.permissions.manage_others_webhooks.name",
+		"authentication.permissions.manage_others_webhooks.description",
+	}
+	PERMISSION_MANAGE_OAUTH = &Permission{
+		"manage_oauth",
+		"authentication.permissions.manage_oauth.name",
+		"authentication.permissions.manage_oauth.description",
+	}
+	PERMISSION_MANAGE_SYSTEM_WIDE_OAUTH = &Permission{
+		"manage_sytem_wide_oauth",
+		"authentication.permissions.manage_sytem_wide_oauth.name",
+		"authentication.permissions.manage_sytem_wide_oauth.description",
+	}
+	PERMISSION_CREATE_POST = &Permission{
+		"create_post",
+		"authentication.permissions.create_post.name",
+		"authentication.permissions.create_post.description",
+	}
+	PERMISSION_EDIT_POST = &Permission{
+		"edit_post",
+		"authentication.permissions.edit_post.name",
+		"authentication.permissions.edit_post.description",
+	}
+	PERMISSION_EDIT_OTHERS_POSTS = &Permission{
+		"edit_others_posts",
+		"authentication.permissions.edit_others_posts.name",
+		"authentication.permissions.edit_others_posts.description",
+	}
+	PERMISSION_REMOVE_USER_FROM_TEAM = &Permission{
+		"remove_user_from_team",
+		"authentication.permissions.remove_user_from_team.name",
+		"authentication.permissions.remove_user_from_team.description",
+	}
+	PERMISSION_MANAGE_TEAM = &Permission{
+		"manage_team",
+		"authentication.permissions.manage_team.name",
+		"authentication.permissions.manage_team.description",
+	}
+	PERMISSION_IMPORT_TEAM = &Permission{
+		"import_team",
+		"authentication.permissions.import_team.name",
+		"authentication.permissions.import_team.description",
+	}
+}
+
+func InitalizeRoles() {
+	InitalizePermissions()
+	BuiltInRoles = make(map[string]*Role)
+
+	ROLE_CHANNEL_USER = &Role{
+		"channel_user",
+		"authentication.roles.channel_user.name",
+		"authentication.roles.channel_user.description",
+		[]string{
+			PERMISSION_READ_CHANNEL.Id,
+			PERMISSION_MANAGE_PUBLIC_CHANNEL_MEMBERS.Id,
+			PERMISSION_MANAGE_PRIVATE_CHANNEL_MEMBERS.Id,
+			PERMISSION_UPLOAD_FILE.Id,
+			PERMISSION_GET_PUBLIC_LINK.Id,
+			PERMISSION_CREATE_POST.Id,
+			PERMISSION_EDIT_POST.Id,
+			PERMISSION_USE_SLASH_COMMANDS.Id,
+		},
+	}
+	BuiltInRoles[ROLE_CHANNEL_USER.Id] = ROLE_CHANNEL_USER
+	ROLE_CHANNEL_ADMIN = &Role{
+		"channel_admin",
+		"authentication.roles.channel_admin.name",
+		"authentication.roles.channel_admin.description",
+		[]string{},
+	}
+	BuiltInRoles[ROLE_CHANNEL_ADMIN.Id] = ROLE_CHANNEL_ADMIN
+	ROLE_CHANNEL_GUEST = &Role{
+		"guest",
+		"authentication.roles.global_guest.name",
+		"authentication.roles.global_guest.description",
+		[]string{},
+	}
+	BuiltInRoles[ROLE_CHANNEL_GUEST.Id] = ROLE_CHANNEL_GUEST
+
+	ROLE_TEAM_USER = &Role{
+		"team_user",
+		"authentication.roles.team_user.name",
+		"authentication.roles.team_user.description",
+		[]string{
+			PERMISSION_LIST_TEAM_CHANNELS.Id,
+			PERMISSION_JOIN_PUBLIC_CHANNELS.Id,
+		},
+	}
+	BuiltInRoles[ROLE_TEAM_USER.Id] = ROLE_TEAM_USER
+	ROLE_TEAM_ADMIN = &Role{
+		"team_admin",
+		"authentication.roles.team_admin.name",
+		"authentication.roles.team_admin.description",
+		[]string{
+			PERMISSION_EDIT_OTHERS_POSTS.Id,
+			PERMISSION_ADD_USER_TO_TEAM.Id,
+			PERMISSION_REMOVE_USER_FROM_TEAM.Id,
+			PERMISSION_MANAGE_TEAM.Id,
+			PERMISSION_IMPORT_TEAM.Id,
+			PERMISSION_MANAGE_ROLES.Id,
+			PERMISSION_MANAGE_OTHERS_WEBHOOKS.Id,
+			PERMISSION_MANAGE_SLASH_COMMANDS.Id,
+			PERMISSION_MANAGE_OTHERS_SLASH_COMMANDS.Id,
+			PERMISSION_MANAGE_WEBHOOKS.Id,
+		},
+	}
+	BuiltInRoles[ROLE_TEAM_ADMIN.Id] = ROLE_TEAM_ADMIN
+
+	ROLE_SYSTEM_USER = &Role{
+		"system_user",
+		"authentication.roles.global_user.name",
+		"authentication.roles.global_user.description",
+		[]string{
+			PERMISSION_CREATE_DIRECT_CHANNEL.Id,
+			PERMISSION_PERMANENT_DELETE_USER.Id,
+			PERMISSION_MANAGE_OAUTH.Id,
+		},
+	}
+	BuiltInRoles[ROLE_SYSTEM_USER.Id] = ROLE_SYSTEM_USER
+	ROLE_SYSTEM_ADMIN = &Role{
+		"system_admin",
+		"authentication.roles.global_admin.name",
+		"authentication.roles.global_admin.description",
+		// System admins can do anything channel and team admins can do
+		// plus everything members of teams and channels can do to all teams
+		// and channels on the system
+		append(
+			append(
+				append(
+					append(
+						[]string{
+							PERMISSION_ASSIGN_SYSTEM_ADMIN_ROLE.Id,
+							PERMISSION_MANAGE_SYSTEM.Id,
+							PERMISSION_MANAGE_PUBLIC_CHANNEL_PROPERTIES.Id,
+							PERMISSION_DELETE_PUBLIC_CHANNEL.Id,
+							PERMISSION_CREATE_PUBLIC_CHANNEL.Id,
+							PERMISSION_MANAGE_PRIVATE_CHANNEL_PROPERTIES.Id,
+							PERMISSION_DELETE_PRIVATE_CHANNEL.Id,
+							PERMISSION_CREATE_PRIVATE_CHANNEL.Id,
+							PERMISSION_MANAGE_SYSTEM_WIDE_OAUTH.Id,
+							PERMISSION_MANAGE_OTHERS_WEBHOOKS.Id,
+							PERMISSION_EDIT_OTHER_USERS.Id,
+							PERMISSION_MANAGE_OAUTH.Id,
+							PERMISSION_INVITE_USER.Id,
+						},
+						ROLE_TEAM_USER.Permissions...,
+					),
+					ROLE_CHANNEL_USER.Permissions...,
+				),
+				ROLE_TEAM_ADMIN.Permissions...,
+			),
+			ROLE_CHANNEL_ADMIN.Permissions...,
+		),
+	}
+	BuiltInRoles[ROLE_SYSTEM_ADMIN.Id] = ROLE_SYSTEM_ADMIN
+
+}
+
+func RoleIdsToString(roles []string) string {
+	output := ""
+	for _, role := range roles {
+		output += role + ", "
+	}
+
+	if output == "" {
+		return "[<NO ROLES>]"
+	}
+
+	return output[:len(output)-1]
+}
+
+func init() {
+	InitalizeRoles()
+}

vendor/github.com/mattermost/platform/model/authorize.go

@@ -11,6 +11,7 @@ import (
 const (
 	AUTHCODE_EXPIRE_TIME   = 60 * 10 // 10 minutes
 	AUTHCODE_RESPONSE_TYPE = "code"
+	DEFAULT_SCOPE          = "user"
 )
 
 type AuthData struct {
@@ -71,6 +72,10 @@ func (ad *AuthData) PreSave() {
 	if ad.CreateAt == 0 {
 		ad.CreateAt = GetMillis()
 	}
+
+	if len(ad.Scope) == 0 {
+		ad.Scope = DEFAULT_SCOPE
+	}
 }
 
 func (ad *AuthData) ToJson() string {

vendor/github.com/mattermost/platform/model/channel.go

@@ -10,10 +10,14 @@ import (
 )
 
 const (
-	CHANNEL_OPEN    = "O"
+	CHANNEL_OPEN                   = "O"
-	CHANNEL_PRIVATE = "P"
+	CHANNEL_PRIVATE                = "P"
-	CHANNEL_DIRECT  = "D"
+	CHANNEL_DIRECT                 = "D"
-	DEFAULT_CHANNEL = "town-square"
+	DEFAULT_CHANNEL                = "town-square"
+	CHANNEL_DISPLAY_NAME_MAX_RUNES = 64
+	CHANNEL_NAME_MAX_LENGTH        = 64
+	CHANNEL_HEADER_MAX_RUNES       = 1024
+	CHANNEL_PURPOSE_MAX_RUNES      = 250
 )
 
 type Channel struct {
@@ -57,8 +61,8 @@ func (o *Channel) Etag() string {
 	return Etag(o.Id, o.UpdateAt)
 }
 
-func (o *Channel) ExtraEtag(memberLimit int) string {
+func (o *Channel) StatsEtag() string {
-	return Etag(o.Id, o.ExtraUpdateAt, memberLimit)
+	return Etag(o.Id, o.ExtraUpdateAt)
 }
 
 func (o *Channel) IsValid() *AppError {
@@ -75,11 +79,11 @@ func (o *Channel) IsValid() *AppError {
 		return NewLocAppError("Channel.IsValid", "model.channel.is_valid.update_at.app_error", nil, "id="+o.Id)
 	}
 
-	if utf8.RuneCountInString(o.DisplayName) > 64 {
+	if utf8.RuneCountInString(o.DisplayName) > CHANNEL_DISPLAY_NAME_MAX_RUNES {
 		return NewLocAppError("Channel.IsValid", "model.channel.is_valid.display_name.app_error", nil, "id="+o.Id)
 	}
 
-	if len(o.Name) > 64 {
+	if len(o.Name) > CHANNEL_NAME_MAX_LENGTH {
 		return NewLocAppError("Channel.IsValid", "model.channel.is_valid.name.app_error", nil, "id="+o.Id)
 	}
 
@@ -91,11 +95,11 @@ func (o *Channel) IsValid() *AppError {
 		return NewLocAppError("Channel.IsValid", "model.channel.is_valid.type.app_error", nil, "id="+o.Id)
 	}
 
-	if utf8.RuneCountInString(o.Header) > 1024 {
+	if utf8.RuneCountInString(o.Header) > CHANNEL_HEADER_MAX_RUNES {
 		return NewLocAppError("Channel.IsValid", "model.channel.is_valid.header.app_error", nil, "id="+o.Id)
 	}
 
-	if utf8.RuneCountInString(o.Purpose) > 128 {
+	if utf8.RuneCountInString(o.Purpose) > CHANNEL_PURPOSE_MAX_RUNES {
 		return NewLocAppError("Channel.IsValid", "model.channel.is_valid.purpose.app_error", nil, "id="+o.Id)
 	}
 
@@ -124,9 +128,6 @@ func (o *Channel) ExtraUpdated() {
 	o.ExtraUpdateAt = GetMillis()
 }
 
-func (o *Channel) PreExport() {
-}
-
 func GetDMNameFromIds(userId1, userId2 string) string {
 	if userId1 > userId2 {
 		return userId2 + "__" + userId1

vendor/github.com/mattermost/platform/model/channel_extra.go

@@ -1,49 +0,0 @@
-// Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
-// See License.txt for license information.
-
-package model
-
-import (
-	"encoding/json"
-	"io"
-)
-
-type ExtraMember struct {
-	Id       string `json:"id"`
-	Nickname string `json:"nickname"`
-	Email    string `json:"email"`
-	Roles    string `json:"roles"`
-	Username string `json:"username"`
-}
-
-func (o *ExtraMember) Sanitize(options map[string]bool) {
-	if len(options) == 0 || !options["email"] {
-		o.Email = ""
-	}
-}
-
-type ChannelExtra struct {
-	Id          string        `json:"id"`
-	Members     []ExtraMember `json:"members"`
-	MemberCount int64         `json:"member_count"`
-}
-
-func (o *ChannelExtra) ToJson() string {
-	b, err := json.Marshal(o)
-	if err != nil {
-		return ""
-	} else {
-		return string(b)
-	}
-}
-
-func ChannelExtraFromJson(data io.Reader) *ChannelExtra {
-	decoder := json.NewDecoder(data)
-	var o ChannelExtra
-	err := decoder.Decode(&o)
-	if err == nil {
-		return &o
-	} else {
-		return nil
-	}
-}

vendor/github.com/mattermost/platform/model/channel_list.go

@@ -8,15 +8,11 @@ import (
 	"io"
 )
 
-type ChannelList struct {
+type ChannelList []*Channel
-	Channels []*Channel                `json:"channels"`
-	Members  map[string]*ChannelMember `json:"members"`
-}
 
 func (o *ChannelList) ToJson() string {
-	b, err := json.Marshal(o)
+	if b, err := json.Marshal(o); err != nil {
-	if err != nil {
+		return "[]"
-		return ""
 	} else {
 		return string(b)
 	}
@@ -28,7 +24,7 @@ func (o *ChannelList) Etag() string {
 	var t int64 = 0
 	var delta int64 = 0
 
-	for _, v := range o.Channels {
+	for _, v := range *o {
 		if v.LastPostAt > t {
 			t = v.LastPostAt
 			id = v.Id
@@ -39,30 +35,9 @@ func (o *ChannelList) Etag() string {
 			id = v.Id
 		}
 
-		member := o.Members[v.Id]
-
-		if member != nil {
-			max := v.LastPostAt
-			if v.UpdateAt > max {
-				max = v.UpdateAt
-			}
-
-			delta += max - member.LastViewedAt
-
-			if member.LastViewedAt > t {
-				t = member.LastViewedAt
-				id = v.Id
-			}
-
-			if member.LastUpdateAt > t {
-				t = member.LastUpdateAt
-				id = v.Id
-			}
-
-		}
 	}
 
-	return Etag(id, t, delta, len(o.Channels))
+	return Etag(id, t, delta, len(*o))
 }
 
 func ChannelListFromJson(data io.Reader) *ChannelList {

vendor/github.com/mattermost/platform/model/channel_member.go

@@ -10,7 +10,6 @@ import (
 )
 
 const (
-	CHANNEL_ROLE_ADMIN          = "admin"
 	CHANNEL_NOTIFY_DEFAULT      = "default"
 	CHANNEL_NOTIFY_ALL          = "all"
 	CHANNEL_NOTIFY_MENTION      = "mention"
@@ -19,6 +18,14 @@ const (
 	CHANNEL_MARK_UNREAD_MENTION = "mention"
 )
 
+type ChannelUnread struct {
+	TeamId        string
+	TotalMsgCount int64
+	MsgCount      int64
+	MentionCount  int64
+	NotifyProps   StringMap
+}
+
 type ChannelMember struct {
 	ChannelId    string    `json:"channel_id"`
 	UserId       string    `json:"user_id"`
@@ -30,6 +37,27 @@ type ChannelMember struct {
 	LastUpdateAt int64     `json:"last_update_at"`
 }
 
+type ChannelMembers []ChannelMember
+
+func (o *ChannelMembers) ToJson() string {
+	if b, err := json.Marshal(o); err != nil {
+		return "[]"
+	} else {
+		return string(b)
+	}
+}
+
+func ChannelMembersFromJson(data io.Reader) *ChannelMembers {
+	decoder := json.NewDecoder(data)
+	var o ChannelMembers
+	err := decoder.Decode(&o)
+	if err == nil {
+		return &o
+	} else {
+		return nil
+	}
+}
+
 func (o *ChannelMember) ToJson() string {
 	b, err := json.Marshal(o)
 	if err != nil {
@@ -60,12 +88,6 @@ func (o *ChannelMember) IsValid() *AppError {
 		return NewLocAppError("ChannelMember.IsValid", "model.channel_member.is_valid.user_id.app_error", nil, "")
 	}
 
-	for _, role := range strings.Split(o.Roles, " ") {
-		if !(role == "" || role == CHANNEL_ROLE_ADMIN) {
-			return NewLocAppError("ChannelMember.IsValid", "model.channel_member.is_valid.role.app_error", nil, "role="+role)
-		}
-	}
-
 	notifyLevel := o.NotifyProps["desktop"]
 	if len(notifyLevel) > 20 || !IsChannelNotifyLevelValid(notifyLevel) {
 		return NewLocAppError("ChannelMember.IsValid", "model.channel_member.is_valid.notify_level.app_error",
@@ -89,6 +111,10 @@ func (o *ChannelMember) PreUpdate() {
 	o.LastUpdateAt = GetMillis()
 }
 
+func (o *ChannelMember) GetRoles() []string {
+	return strings.Fields(o.Roles)
+}
+
 func IsChannelNotifyLevelValid(notifyLevel string) bool {
 	return notifyLevel == CHANNEL_NOTIFY_DEFAULT ||
 		notifyLevel == CHANNEL_NOTIFY_ALL ||

vendor/github.com/mattermost/platform/model/channel_search.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package model
+
+import (
+	"encoding/json"
+	"io"
+)
+
+type ChannelSearch struct {
+	Term string `json:"term"`
+}
+
+// ToJson convert a Channel to a json string
+func (c *ChannelSearch) ToJson() string {
+	b, err := json.Marshal(c)
+	if err != nil {
+		return ""
+	} else {
+		return string(b)
+	}
+}
+
+// ChannelSearchFromJson will decode the input and return a Channel
+func ChannelSearchFromJson(data io.Reader) *ChannelSearch {
+	decoder := json.NewDecoder(data)
+	var cs ChannelSearch
+	err := decoder.Decode(&cs)
+	if err == nil {
+		return &cs
+	} else {
+		return nil
+	}
+}

vendor/github.com/mattermost/platform/model/channel_stats.go

@@ -5,32 +5,15 @@ package model
 
 import (
 	"encoding/json"
-	"fmt"
 	"io"
 )
 
-type TeamSignup struct {
+type ChannelStats struct {
-	Team    Team     `json:"team"`
+	ChannelId   string `json:"channel_id"`
-	User    User     `json:"user"`
+	MemberCount int64  `json:"member_count"`
-	Invites []string `json:"invites"`
-	Data    string   `json:"data"`
-	Hash    string   `json:"hash"`
 }
 
-func TeamSignupFromJson(data io.Reader) *TeamSignup {
+func (o *ChannelStats) ToJson() string {
-	decoder := json.NewDecoder(data)
-	var o TeamSignup
-	err := decoder.Decode(&o)
-	if err == nil {
-		return &o
-	} else {
-		fmt.Println(err)
-
-		return nil
-	}
-}
-
-func (o *TeamSignup) ToJson() string {
 	b, err := json.Marshal(o)
 	if err != nil {
 		return ""
@@ -38,3 +21,14 @@ func (o *TeamSignup) ToJson() string {
 		return string(b)
 	}
 }
+
+func ChannelStatsFromJson(data io.Reader) *ChannelStats {
+	decoder := json.NewDecoder(data)
+	var o ChannelStats
+	err := decoder.Decode(&o)
+	if err == nil {
+		return &o
+	} else {
+		return nil
+	}
+}

vendor/github.com/mattermost/platform/model/channel_view.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package model
+
+import (
+	"encoding/json"
+	"io"
+)
+
+type ChannelView struct {
+	ChannelId     string `json:"channel_id"`
+	PrevChannelId string `json:"prev_channel_id"`
+}
+
+func (o *ChannelView) ToJson() string {
+	b, err := json.Marshal(o)
+	if err != nil {
+		return ""
+	} else {
+		return string(b)
+	}
+}
+
+func ChannelViewFromJson(data io.Reader) *ChannelView {
+	decoder := json.NewDecoder(data)
+	var o ChannelView
+	err := decoder.Decode(&o)
+	if err == nil {
+		return &o
+	} else {
+		return nil
+	}
+}

vendor/github.com/mattermost/platform/model/cluster_info.go

@@ -0,0 +1,66 @@
+// Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package model
+
+import (
+	"encoding/json"
+	"io"
+)
+
+type ClusterInfo struct {
+	Id                 string `json:"id"`
+	Version            string `json:"version"`
+	ConfigHash         string `json:"config_hash"`
+	InterNodeUrl       string `json:"internode_url"`
+	Hostname           string `json:"hostname"`
+	LastSuccessfulPing int64  `json:"last_ping"`
+	IsAlive            bool   `json:"is_alive"`
+}
+
+func (me *ClusterInfo) ToJson() string {
+	b, err := json.Marshal(me)
+	if err != nil {
+		return ""
+	} else {
+		return string(b)
+	}
+}
+
+func ClusterInfoFromJson(data io.Reader) *ClusterInfo {
+	decoder := json.NewDecoder(data)
+	var me ClusterInfo
+	err := decoder.Decode(&me)
+	if err == nil {
+		return &me
+	} else {
+		return nil
+	}
+}
+
+func (me *ClusterInfo) HaveEstablishedInitialContact() bool {
+	if me.Id != "" {
+		return true
+	}
+
+	return false
+}
+
+func ClusterInfosToJson(objmap []*ClusterInfo) string {
+	if b, err := json.Marshal(objmap); err != nil {
+		return ""
+	} else {
+		return string(b)
+	}
+}
+
+func ClusterInfosFromJson(data io.Reader) []*ClusterInfo {
+	decoder := json.NewDecoder(data)
+
+	var objmap []*ClusterInfo
+	if err := decoder.Decode(&objmap); err != nil {
+		return make([]*ClusterInfo, 0)
+	} else {
+		return objmap
+	}
+}

vendor/github.com/mattermost/platform/model/cluster_stats.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package model
+
+import (
+	"encoding/json"
+	"io"
+)
+
+type ClusterStats struct {
+	Id                        string `json:"id"`
+	TotalWebsocketConnections int    `json:"total_websocket_connections"`
+	TotalReadDbConnections    int    `json:"total_read_db_connections"`
+	TotalMasterDbConnections  int    `json:"total_master_db_connections"`
+}
+
+func (me *ClusterStats) ToJson() string {
+	b, err := json.Marshal(me)
+	if err != nil {
+		return ""
+	} else {
+		return string(b)
+	}
+}
+
+func ClusterStatsFromJson(data io.Reader) *ClusterStats {
+	decoder := json.NewDecoder(data)
+	var me ClusterStats
+	err := decoder.Decode(&me)
+	if err == nil {
+		return &me
+	} else {
+		return nil
+	}
+}

vendor/github.com/mattermost/platform/model/command_args.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+package model
+
+import (
+	"encoding/json"
+	"io"
+)
+
+type CommandArgs struct {
+	ChannelId string `json:"channel_id"`
+	RootId    string `json:"root_id"`
+	ParentId  string `json:"parent_id"`
+	Command   string `json:"command"`
+}
+
+func (o *CommandArgs) ToJson() string {
+	b, err := json.Marshal(o)
+	if err != nil {
+		return ""
+	} else {
+		return string(b)
+	}
+}
+
+func CommandArgsFromJson(data io.Reader) *CommandArgs {
+	decoder := json.NewDecoder(data)
+	var o CommandArgs
+	err := decoder.Decode(&o)
+	if err == nil {
+		return &o
+	} else {
+		return nil
+	}
+}

vendor/github.com/mattermost/platform/model/command_response.go

@@ -16,6 +16,8 @@ const (
 type CommandResponse struct {
 	ResponseType string      `json:"response_type"`
 	Text         string      `json:"text"`
+	Username     string      `json:"username"`
+	IconURL      string      `json:"icon_url"`
 	GotoLocation string      `json:"goto_location"`
 	Attachments  interface{} `json:"attachments"`
 }

vendor/github.com/mattermost/platform/model/compliance_post.go

@@ -34,7 +34,7 @@ type CompliancePost struct {
 	PostType       string
 	PostProps      string
 	PostHashtags   string
-	PostFilenames  string
+	PostFileIds    string
 }
 
 func CompliancePostHeader() []string {
@@ -60,7 +60,7 @@ func CompliancePostHeader() []string {
 		"PostType",
 		"PostProps",
 		"PostHashtags",
-		"PostFilenames",
+		"PostFileIds",
 	}
 }
 
@@ -99,6 +99,6 @@ func (me *CompliancePost) Row() []string {
 		me.PostType,
 		me.PostProps,
 		me.PostHashtags,
-		me.PostFilenames,
+		me.PostFileIds,
 	}
 }

vendor/github.com/mattermost/platform/model/config.go

@@ -6,10 +6,12 @@ package model
 import (
 	"encoding/json"
 	"io"
+	"net/url"
 )
 
 const (
 	CONN_SECURITY_NONE     = ""
+	CONN_SECURITY_PLAIN    = "PLAIN"
 	CONN_SECURITY_TLS      = "TLS"
 	CONN_SECURITY_STARTTLS = "STARTTLS"
 
@@ -22,8 +24,9 @@ const (
 	PASSWORD_MAXIMUM_LENGTH = 64
 	PASSWORD_MINIMUM_LENGTH = 5
 
-	SERVICE_GITLAB = "gitlab"
+	SERVICE_GITLAB    = "gitlab"
-	SERVICE_GOOGLE = "google"
+	SERVICE_GOOGLE    = "google"
+	SERVICE_OFFICE365 = "office365"
 
 	WEBSERVER_MODE_REGULAR  = "regular"
 	WEBSERVER_MODE_GZIP     = "gzip"
@@ -35,19 +38,34 @@ const (
 	DIRECT_MESSAGE_ANY  = "any"
 	DIRECT_MESSAGE_TEAM = "team"
 
-	PERMISSIONS_ALL          = "all"
+	PERMISSIONS_ALL           = "all"
-	PERMISSIONS_TEAM_ADMIN   = "team_admin"
+	PERMISSIONS_CHANNEL_ADMIN = "channel_admin"
-	PERMISSIONS_SYSTEM_ADMIN = "system_admin"
+	PERMISSIONS_TEAM_ADMIN    = "team_admin"
+	PERMISSIONS_SYSTEM_ADMIN  = "system_admin"
 
 	FAKE_SETTING = "********************************"
 
 	RESTRICT_EMOJI_CREATION_ALL          = "all"
 	RESTRICT_EMOJI_CREATION_ADMIN        = "admin"
 	RESTRICT_EMOJI_CREATION_SYSTEM_ADMIN = "system_admin"
+
+	EMAIL_BATCHING_BUFFER_SIZE = 256
+	EMAIL_BATCHING_INTERVAL    = 30
+
+	SITENAME_MAX_LENGTH = 30
 )
 
 type ServiceSettings struct {
+	SiteURL                           *string
 	ListenAddress                     string
+	ConnectionSecurity                *string
+	TLSCertFile                       *string
+	TLSKeyFile                        *string
+	UseLetsEncrypt                    *bool
+	LetsEncryptCertificateCacheFile   *string
+	Forward80To443                    *bool
+	ReadTimeout                       *int
+	WriteTimeout                      *int
 	MaximumLoginAttempts              int
 	SegmentDeveloperKey               string
 	GoogleDeveloperKey                string
@@ -63,6 +81,7 @@ type ServiceSettings struct {
 	EnableSecurityFixAlert            *bool
 	EnableInsecureOutgoingConnections *bool
 	EnableMultifactorAuthentication   *bool
+	EnforceMultifactorAuthentication  *bool
 	AllowCorsFrom                     *string
 	SessionLengthWebInDays            *int
 	SessionLengthMobileInDays         *int
@@ -75,6 +94,22 @@ type ServiceSettings struct {
 	RestrictCustomEmojiCreation       *string
 }
 
+type ClusterSettings struct {
+	Enable                 *bool
+	InterNodeListenAddress *string
+	InterNodeUrls          []string
+}
+
+type MetricsSettings struct {
+	Enable           *bool
+	BlockProfileRate *int
+	ListenAddress    *string
+}
+
+type AnalyticsSettings struct {
+	MaxUsersForStatistics *int
+}
+
 type SSOSettings struct {
 	Enable          bool
 	Secret          string
@@ -103,6 +138,7 @@ type LogSettings struct {
 	FileFormat             string
 	FileLocation           string
 	EnableWebhookDebugging bool
+	EnableDiagnostics      *bool
 }
 
 type PasswordSettings struct {
@@ -114,26 +150,24 @@ type PasswordSettings struct {
 }
 
 type FileSettings struct {
-	MaxFileSize                *int64
+	MaxFileSize             *int64
-	DriverName                 string
+	DriverName              string
-	Directory                  string
+	Directory               string
-	EnablePublicLink           bool
+	EnablePublicLink        bool
-	PublicLinkSalt             string
+	PublicLinkSalt          *string
-	ThumbnailWidth             int
+	ThumbnailWidth          int
-	ThumbnailHeight            int
+	ThumbnailHeight         int
-	PreviewWidth               int
+	PreviewWidth            int
-	PreviewHeight              int
+	PreviewHeight           int
-	ProfileWidth               int
+	ProfileWidth            int
-	ProfileHeight              int
+	ProfileHeight           int
-	InitialFont                string
+	InitialFont             string
-	AmazonS3AccessKeyId        string
+	AmazonS3AccessKeyId     string
-	AmazonS3SecretAccessKey    string
+	AmazonS3SecretAccessKey string
-	AmazonS3Bucket             string
+	AmazonS3Bucket          string
-	AmazonS3Region             string
+	AmazonS3Region          string
-	AmazonS3Endpoint           string
+	AmazonS3Endpoint        string
-	AmazonS3BucketEndpoint     string
+	AmazonS3SSL             *bool
-	AmazonS3LocationConstraint *bool
-	AmazonS3LowercaseBucket    *bool
 }
 
 type EmailSettings struct {
@@ -155,14 +189,18 @@ type EmailSettings struct {
 	SendPushNotifications    *bool
 	PushNotificationServer   *string
 	PushNotificationContents *string
+	EnableEmailBatching      *bool
+	EmailBatchingBufferSize  *int
+	EmailBatchingInterval    *int
 }
 
 type RateLimitSettings struct {
-	EnableRateLimiter bool
+	Enable           *bool
-	PerSec            int
+	PerSec           int
-	MemoryStoreSize   int
+	MaxBurst         *int
-	VaryByRemoteAddr  bool
+	MemoryStoreSize  int
-	VaryByHeader      string
+	VaryByRemoteAddr bool
+	VaryByHeader     string
 }
 
 type PrivacySettings struct {
@@ -186,13 +224,20 @@ type TeamSettings struct {
 	EnableUserCreation               bool
 	EnableOpenServer                 *bool
 	RestrictCreationToDomains        string
-	RestrictTeamNames                *bool
 	EnableCustomBrand                *bool
 	CustomBrandText                  *string
+	CustomDescriptionText            *string
 	RestrictDirectMessage            *string
 	RestrictTeamInvite               *string
 	RestrictPublicChannelManagement  *string
 	RestrictPrivateChannelManagement *string
+	RestrictPublicChannelCreation    *string
+	RestrictPrivateChannelCreation   *string
+	RestrictPublicChannelDeletion    *string
+	RestrictPrivateChannelDeletion   *string
+	UserStatusAwayTimeout            *int64
+	MaxChannelsPerTeam               *int64
+	MaxNotificationsPerChannel       *int64
 }
 
 type LdapSettings struct {
@@ -215,6 +260,7 @@ type LdapSettings struct {
 	UsernameAttribute  *string
 	NicknameAttribute  *string
 	IdAttribute        *string
+	PositionAttribute  *string
 
 	// Syncronization
 	SyncIntervalMinutes *int
@@ -261,10 +307,28 @@ type SamlSettings struct {
 	UsernameAttribute  *string
 	NicknameAttribute  *string
 	LocaleAttribute    *string
+	PositionAttribute  *string
 
 	LoginButtonText *string
 }
 
+type NativeAppSettings struct {
+	AppDownloadLink        *string
+	AndroidAppDownloadLink *string
+	IosAppDownloadLink     *string
+}
+
+type WebrtcSettings struct {
+	Enable              *bool
+	GatewayWebsocketUrl *string
+	GatewayAdminUrl     *string
+	GatewayAdminSecret  *string
+	StunURI             *string
+	TurnURI             *string
+	TurnUsername        *string
+	TurnSharedKey       *string
+}
+
 type Config struct {
 	ServiceSettings      ServiceSettings
 	TeamSettings         TeamSettings
@@ -278,10 +342,16 @@ type Config struct {
 	SupportSettings      SupportSettings
 	GitLabSettings       SSOSettings
 	GoogleSettings       SSOSettings
+	Office365Settings    SSOSettings
 	LdapSettings         LdapSettings
 	ComplianceSettings   ComplianceSettings
 	LocalizationSettings LocalizationSettings
 	SamlSettings         SamlSettings
+	NativeAppSettings    NativeAppSettings
+	ClusterSettings      ClusterSettings
+	MetricsSettings      MetricsSettings
+	AnalyticsSettings    AnalyticsSettings
+	WebrtcSettings       WebrtcSettings
 }
 
 func (o *Config) ToJson() string {
@@ -299,6 +369,8 @@ func (o *Config) GetSSOService(service string) *SSOSettings {
 		return &o.GitLabSettings
 	case SERVICE_GOOGLE:
 		return &o.GoogleSettings
+	case SERVICE_OFFICE365:
+		return &o.Office365Settings
 	}
 
 	return nil
@@ -321,23 +393,34 @@ func (o *Config) SetDefaults() {
 		o.SqlSettings.AtRestEncryptKey = NewRandomString(32)
 	}
 
+	if o.FileSettings.AmazonS3Endpoint == "" {
+		// Defaults to "s3.amazonaws.com"
+		o.FileSettings.AmazonS3Endpoint = "s3.amazonaws.com"
+	}
+
+	if o.FileSettings.AmazonS3Region == "" {
+		// Defaults to "us-east-1" region.
+		o.FileSettings.AmazonS3Region = "us-east-1"
+	}
+
+	if o.FileSettings.AmazonS3SSL == nil {
+		o.FileSettings.AmazonS3SSL = new(bool)
+		*o.FileSettings.AmazonS3SSL = true // Secure by default.
+	}
+
 	if o.FileSettings.MaxFileSize == nil {
 		o.FileSettings.MaxFileSize = new(int64)
 		*o.FileSettings.MaxFileSize = 52428800 // 50 MB
 	}
 
-	if len(o.FileSettings.PublicLinkSalt) == 0 {
+	if len(*o.FileSettings.PublicLinkSalt) == 0 {
-		o.FileSettings.PublicLinkSalt = NewRandomString(32)
+		o.FileSettings.PublicLinkSalt = new(string)
+		*o.FileSettings.PublicLinkSalt = NewRandomString(32)
 	}
 
-	if o.FileSettings.AmazonS3LocationConstraint == nil {
+	if o.FileSettings.InitialFont == "" {
-		o.FileSettings.AmazonS3LocationConstraint = new(bool)
+		// Defaults to "luximbi.ttf"
-		*o.FileSettings.AmazonS3LocationConstraint = false
+		o.FileSettings.InitialFont = "luximbi.ttf"
-	}
-
-	if o.FileSettings.AmazonS3LowercaseBucket == nil {
-		o.FileSettings.AmazonS3LowercaseBucket = new(bool)
-		*o.FileSettings.AmazonS3LowercaseBucket = false
 	}
 
 	if len(o.EmailSettings.InviteSalt) == 0 {
@@ -348,6 +431,11 @@ func (o *Config) SetDefaults() {
 		o.EmailSettings.PasswordResetSalt = NewRandomString(32)
 	}
 
+	if o.ServiceSettings.SiteURL == nil {
+		o.ServiceSettings.SiteURL = new(string)
+		*o.ServiceSettings.SiteURL = ""
+	}
+
 	if o.ServiceSettings.EnableDeveloper == nil {
 		o.ServiceSettings.EnableDeveloper = new(bool)
 		*o.ServiceSettings.EnableDeveloper = false
@@ -368,6 +456,11 @@ func (o *Config) SetDefaults() {
 		*o.ServiceSettings.EnableMultifactorAuthentication = false
 	}
 
+	if o.ServiceSettings.EnforceMultifactorAuthentication == nil {
+		o.ServiceSettings.EnforceMultifactorAuthentication = new(bool)
+		*o.ServiceSettings.EnforceMultifactorAuthentication = false
+	}
+
 	if o.PasswordSettings.MinimumLength == nil {
 		o.PasswordSettings.MinimumLength = new(int)
 		*o.PasswordSettings.MinimumLength = PASSWORD_MINIMUM_LENGTH
@@ -393,11 +486,6 @@ func (o *Config) SetDefaults() {
 		*o.PasswordSettings.Symbol = false
 	}
 
-	if o.TeamSettings.RestrictTeamNames == nil {
-		o.TeamSettings.RestrictTeamNames = new(bool)
-		*o.TeamSettings.RestrictTeamNames = true
-	}
-
 	if o.TeamSettings.EnableCustomBrand == nil {
 		o.TeamSettings.EnableCustomBrand = new(bool)
 		*o.TeamSettings.EnableCustomBrand = false
@@ -408,6 +496,11 @@ func (o *Config) SetDefaults() {
 		*o.TeamSettings.CustomBrandText = ""
 	}
 
+	if o.TeamSettings.CustomDescriptionText == nil {
+		o.TeamSettings.CustomDescriptionText = new(string)
+		*o.TeamSettings.CustomDescriptionText = ""
+	}
+
 	if o.TeamSettings.EnableOpenServer == nil {
 		o.TeamSettings.EnableOpenServer = new(bool)
 		*o.TeamSettings.EnableOpenServer = false
@@ -433,6 +526,45 @@ func (o *Config) SetDefaults() {
 		*o.TeamSettings.RestrictPrivateChannelManagement = PERMISSIONS_ALL
 	}
 
+	if o.TeamSettings.RestrictPublicChannelCreation == nil {
+		o.TeamSettings.RestrictPublicChannelCreation = new(string)
+		// If this setting does not exist, assume migration from <3.6, so use management setting as default.
+		*o.TeamSettings.RestrictPublicChannelCreation = *o.TeamSettings.RestrictPublicChannelManagement
+	}
+
+	if o.TeamSettings.RestrictPrivateChannelCreation == nil {
+		o.TeamSettings.RestrictPrivateChannelCreation = new(string)
+		// If this setting does not exist, assume migration from <3.6, so use management setting as default.
+		*o.TeamSettings.RestrictPrivateChannelCreation = *o.TeamSettings.RestrictPrivateChannelManagement
+	}
+
+	if o.TeamSettings.RestrictPublicChannelDeletion == nil {
+		o.TeamSettings.RestrictPublicChannelDeletion = new(string)
+		// If this setting does not exist, assume migration from <3.6, so use management setting as default.
+		*o.TeamSettings.RestrictPublicChannelDeletion = *o.TeamSettings.RestrictPublicChannelManagement
+	}
+
+	if o.TeamSettings.RestrictPrivateChannelDeletion == nil {
+		o.TeamSettings.RestrictPrivateChannelDeletion = new(string)
+		// If this setting does not exist, assume migration from <3.6, so use management setting as default.
+		*o.TeamSettings.RestrictPrivateChannelDeletion = *o.TeamSettings.RestrictPrivateChannelManagement
+	}
+
+	if o.TeamSettings.UserStatusAwayTimeout == nil {
+		o.TeamSettings.UserStatusAwayTimeout = new(int64)
+		*o.TeamSettings.UserStatusAwayTimeout = 300
+	}
+
+	if o.TeamSettings.MaxChannelsPerTeam == nil {
+		o.TeamSettings.MaxChannelsPerTeam = new(int64)
+		*o.TeamSettings.MaxChannelsPerTeam = 2000
+	}
+
+	if o.TeamSettings.MaxNotificationsPerChannel == nil {
+		o.TeamSettings.MaxNotificationsPerChannel = new(int64)
+		*o.TeamSettings.MaxNotificationsPerChannel = 1000
+	}
+
 	if o.EmailSettings.EnableSignInWithEmail == nil {
 		o.EmailSettings.EnableSignInWithEmail = new(bool)
 
@@ -468,13 +600,28 @@ func (o *Config) SetDefaults() {
 		*o.EmailSettings.FeedbackOrganization = ""
 	}
 
+	if o.EmailSettings.EnableEmailBatching == nil {
+		o.EmailSettings.EnableEmailBatching = new(bool)
+		*o.EmailSettings.EnableEmailBatching = false
+	}
+
+	if o.EmailSettings.EmailBatchingBufferSize == nil {
+		o.EmailSettings.EmailBatchingBufferSize = new(int)
+		*o.EmailSettings.EmailBatchingBufferSize = EMAIL_BATCHING_BUFFER_SIZE
+	}
+
+	if o.EmailSettings.EmailBatchingInterval == nil {
+		o.EmailSettings.EmailBatchingInterval = new(int)
+		*o.EmailSettings.EmailBatchingInterval = EMAIL_BATCHING_INTERVAL
+	}
+
 	if !IsSafeLink(o.SupportSettings.TermsOfServiceLink) {
 		o.SupportSettings.TermsOfServiceLink = nil
 	}
 
 	if o.SupportSettings.TermsOfServiceLink == nil {
 		o.SupportSettings.TermsOfServiceLink = new(string)
-		*o.SupportSettings.TermsOfServiceLink = "/static/help/terms.html"
+		*o.SupportSettings.TermsOfServiceLink = "https://about.mattermost.com/default-terms/"
 	}
 
 	if !IsSafeLink(o.SupportSettings.PrivacyPolicyLink) {
@@ -483,7 +630,7 @@ func (o *Config) SetDefaults() {
 
 	if o.SupportSettings.PrivacyPolicyLink == nil {
 		o.SupportSettings.PrivacyPolicyLink = new(string)
-		*o.SupportSettings.PrivacyPolicyLink = "/static/help/privacy.html"
+		*o.SupportSettings.PrivacyPolicyLink = ""
 	}
 
 	if !IsSafeLink(o.SupportSettings.AboutLink) {
@@ -492,7 +639,7 @@ func (o *Config) SetDefaults() {
 
 	if o.SupportSettings.AboutLink == nil {
 		o.SupportSettings.AboutLink = new(string)
-		*o.SupportSettings.AboutLink = "/static/help/about.html"
+		*o.SupportSettings.AboutLink = ""
 	}
 
 	if !IsSafeLink(o.SupportSettings.HelpLink) {
@@ -501,7 +648,7 @@ func (o *Config) SetDefaults() {
 
 	if o.SupportSettings.HelpLink == nil {
 		o.SupportSettings.HelpLink = new(string)
-		*o.SupportSettings.HelpLink = "/static/help/help.html"
+		*o.SupportSettings.HelpLink = ""
 	}
 
 	if !IsSafeLink(o.SupportSettings.ReportAProblemLink) {
@@ -510,7 +657,7 @@ func (o *Config) SetDefaults() {
 
 	if o.SupportSettings.ReportAProblemLink == nil {
 		o.SupportSettings.ReportAProblemLink = new(string)
-		*o.SupportSettings.ReportAProblemLink = "/static/help/report_problem.html"
+		*o.SupportSettings.ReportAProblemLink = ""
 	}
 
 	if o.SupportSettings.SupportEmail == nil {
@@ -588,6 +735,11 @@ func (o *Config) SetDefaults() {
 		*o.LdapSettings.IdAttribute = ""
 	}
 
+	if o.LdapSettings.PositionAttribute == nil {
+		o.LdapSettings.PositionAttribute = new(string)
+		*o.LdapSettings.PositionAttribute = ""
+	}
+
 	if o.LdapSettings.SyncIntervalMinutes == nil {
 		o.LdapSettings.SyncIntervalMinutes = new(int)
 		*o.LdapSettings.SyncIntervalMinutes = 60
@@ -675,6 +827,35 @@ func (o *Config) SetDefaults() {
 		*o.ServiceSettings.RestrictCustomEmojiCreation = RESTRICT_EMOJI_CREATION_ALL
 	}
 
+	if o.ClusterSettings.InterNodeListenAddress == nil {
+		o.ClusterSettings.InterNodeListenAddress = new(string)
+		*o.ClusterSettings.InterNodeListenAddress = ":8075"
+	}
+
+	if o.ClusterSettings.Enable == nil {
+		o.ClusterSettings.Enable = new(bool)
+		*o.ClusterSettings.Enable = false
+	}
+
+	if o.ClusterSettings.InterNodeUrls == nil {
+		o.ClusterSettings.InterNodeUrls = []string{}
+	}
+
+	if o.MetricsSettings.ListenAddress == nil {
+		o.MetricsSettings.ListenAddress = new(string)
+		*o.MetricsSettings.ListenAddress = ":8067"
+	}
+
+	if o.MetricsSettings.Enable == nil {
+		o.MetricsSettings.Enable = new(bool)
+		*o.MetricsSettings.Enable = false
+	}
+
+	if o.AnalyticsSettings.MaxUsersForStatistics == nil {
+		o.AnalyticsSettings.MaxUsersForStatistics = new(int)
+		*o.AnalyticsSettings.MaxUsersForStatistics = 2500
+	}
+
 	if o.ComplianceSettings.Enable == nil {
 		o.ComplianceSettings.Enable = new(bool)
 		*o.ComplianceSettings.Enable = false
@@ -705,6 +886,11 @@ func (o *Config) SetDefaults() {
 		*o.LocalizationSettings.AvailableLocales = ""
 	}
 
+	if o.LogSettings.EnableDiagnostics == nil {
+		o.LogSettings.EnableDiagnostics = new(bool)
+		*o.LogSettings.EnableDiagnostics = true
+	}
+
 	if o.SamlSettings.Enable == nil {
 		o.SamlSettings.Enable = new(bool)
 		*o.SamlSettings.Enable = false
@@ -780,10 +966,87 @@ func (o *Config) SetDefaults() {
 		*o.SamlSettings.NicknameAttribute = ""
 	}
 
+	if o.SamlSettings.PositionAttribute == nil {
+		o.SamlSettings.PositionAttribute = new(string)
+		*o.SamlSettings.PositionAttribute = ""
+	}
+
 	if o.SamlSettings.LocaleAttribute == nil {
 		o.SamlSettings.LocaleAttribute = new(string)
 		*o.SamlSettings.LocaleAttribute = ""
 	}
+
+	if o.NativeAppSettings.AppDownloadLink == nil {
+		o.NativeAppSettings.AppDownloadLink = new(string)
+		*o.NativeAppSettings.AppDownloadLink = "https://about.mattermost.com/downloads/"
+	}
+
+	if o.NativeAppSettings.AndroidAppDownloadLink == nil {
+		o.NativeAppSettings.AndroidAppDownloadLink = new(string)
+		*o.NativeAppSettings.AndroidAppDownloadLink = "https://about.mattermost.com/mattermost-android-app/"
+	}
+
+	if o.NativeAppSettings.IosAppDownloadLink == nil {
+		o.NativeAppSettings.IosAppDownloadLink = new(string)
+		*o.NativeAppSettings.IosAppDownloadLink = "https://about.mattermost.com/mattermost-ios-app/"
+	}
+
+	if o.RateLimitSettings.Enable == nil {
+		o.RateLimitSettings.Enable = new(bool)
+		*o.RateLimitSettings.Enable = false
+	}
+
+	if o.RateLimitSettings.MaxBurst == nil {
+		o.RateLimitSettings.MaxBurst = new(int)
+		*o.RateLimitSettings.MaxBurst = 100
+	}
+
+	if o.ServiceSettings.ConnectionSecurity == nil {
+		o.ServiceSettings.ConnectionSecurity = new(string)
+		*o.ServiceSettings.ConnectionSecurity = ""
+	}
+
+	if o.ServiceSettings.TLSKeyFile == nil {
+		o.ServiceSettings.TLSKeyFile = new(string)
+		*o.ServiceSettings.TLSKeyFile = ""
+	}
+
+	if o.ServiceSettings.TLSCertFile == nil {
+		o.ServiceSettings.TLSCertFile = new(string)
+		*o.ServiceSettings.TLSCertFile = ""
+	}
+
+	if o.ServiceSettings.UseLetsEncrypt == nil {
+		o.ServiceSettings.UseLetsEncrypt = new(bool)
+		*o.ServiceSettings.UseLetsEncrypt = false
+	}
+
+	if o.ServiceSettings.LetsEncryptCertificateCacheFile == nil {
+		o.ServiceSettings.LetsEncryptCertificateCacheFile = new(string)
+		*o.ServiceSettings.LetsEncryptCertificateCacheFile = "./config/letsencrypt.cache"
+	}
+
+	if o.ServiceSettings.ReadTimeout == nil {
+		o.ServiceSettings.ReadTimeout = new(int)
+		*o.ServiceSettings.ReadTimeout = 300
+	}
+
+	if o.ServiceSettings.WriteTimeout == nil {
+		o.ServiceSettings.WriteTimeout = new(int)
+		*o.ServiceSettings.WriteTimeout = 300
+	}
+
+	if o.ServiceSettings.Forward80To443 == nil {
+		o.ServiceSettings.Forward80To443 = new(bool)
+		*o.ServiceSettings.Forward80To443 = false
+	}
+
+	if o.MetricsSettings.BlockProfileRate == nil {
+		o.MetricsSettings.BlockProfileRate = new(int)
+		*o.MetricsSettings.BlockProfileRate = 0
+	}
+
+	o.defaultWebrtcSettings()
 }
 
 func (o *Config) IsValid() *AppError {
@@ -792,14 +1055,36 @@ func (o *Config) IsValid() *AppError {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.login_attempts.app_error", nil, "")
 	}
 
+	if len(*o.ServiceSettings.SiteURL) != 0 {
+		if _, err := url.ParseRequestURI(*o.ServiceSettings.SiteURL); err != nil {
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.site_url.app_error", nil, "")
+		}
+	}
+
 	if len(o.ServiceSettings.ListenAddress) == 0 {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.listen_address.app_error", nil, "")
 	}
 
+	if *o.ClusterSettings.Enable && *o.EmailSettings.EnableEmailBatching {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.cluster_email_batching.app_error", nil, "")
+	}
+
+	if len(*o.ServiceSettings.SiteURL) == 0 && *o.EmailSettings.EnableEmailBatching {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.site_url_email_batching.app_error", nil, "")
+	}
+
 	if o.TeamSettings.MaxUsersPerTeam <= 0 {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.max_users.app_error", nil, "")
 	}
 
+	if *o.TeamSettings.MaxChannelsPerTeam <= 0 {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.max_channels.app_error", nil, "")
+	}
+
+	if *o.TeamSettings.MaxNotificationsPerChannel <= 0 {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.max_notify_per_channel.app_error", nil, "")
+	}
+
 	if !(*o.TeamSettings.RestrictDirectMessage == DIRECT_MESSAGE_ANY || *o.TeamSettings.RestrictDirectMessage == DIRECT_MESSAGE_TEAM) {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.restrict_direct_message.app_error", nil, "")
 	}
@@ -856,11 +1141,11 @@ func (o *Config) IsValid() *AppError {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.file_thumb_width.app_error", nil, "")
 	}
 
-	if len(o.FileSettings.PublicLinkSalt) < 32 {
+	if len(*o.FileSettings.PublicLinkSalt) < 32 {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.file_salt.app_error", nil, "")
 	}
 
-	if !(o.EmailSettings.ConnectionSecurity == CONN_SECURITY_NONE || o.EmailSettings.ConnectionSecurity == CONN_SECURITY_TLS || o.EmailSettings.ConnectionSecurity == CONN_SECURITY_STARTTLS) {
+	if !(o.EmailSettings.ConnectionSecurity == CONN_SECURITY_NONE || o.EmailSettings.ConnectionSecurity == CONN_SECURITY_TLS || o.EmailSettings.ConnectionSecurity == CONN_SECURITY_STARTTLS || o.EmailSettings.ConnectionSecurity == CONN_SECURITY_PLAIN) {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.email_security.app_error", nil, "")
 	}
 
@@ -872,6 +1157,14 @@ func (o *Config) IsValid() *AppError {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.email_reset_salt.app_error", nil, "")
 	}
 
+	if *o.EmailSettings.EmailBatchingBufferSize <= 0 {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.email_batching_buffer_size.app_error", nil, "")
+	}
+
+	if *o.EmailSettings.EmailBatchingInterval < 30 {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.email_batching_interval.app_error", nil, "")
+	}
+
 	if o.RateLimitSettings.MemoryStoreSize <= 0 {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.rate_mem.app_error", nil, "")
 	}
@@ -893,21 +1186,29 @@ func (o *Config) IsValid() *AppError {
 	}
 
 	if *o.LdapSettings.Enable {
-		if *o.LdapSettings.LdapServer == "" ||
+		if *o.LdapSettings.LdapServer == "" {
-			*o.LdapSettings.BaseDN == "" ||
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.ldap_server", nil, "")
-			*o.LdapSettings.BindUsername == "" ||
+		}
-			*o.LdapSettings.BindPassword == "" ||
+
-			*o.LdapSettings.FirstNameAttribute == "" ||
+		if *o.LdapSettings.BaseDN == "" {
-			*o.LdapSettings.LastNameAttribute == "" ||
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.ldap_basedn", nil, "")
-			*o.LdapSettings.EmailAttribute == "" ||
+		}
-			*o.LdapSettings.UsernameAttribute == "" ||
+
-			*o.LdapSettings.IdAttribute == "" {
+		if *o.LdapSettings.EmailAttribute == "" {
-			return NewLocAppError("Config.IsValid", "Required LDAP field missing", nil, "")
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.ldap_email", nil, "")
+		}
+
+		if *o.LdapSettings.UsernameAttribute == "" {
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.ldap_username", nil, "")
+		}
+
+		if *o.LdapSettings.IdAttribute == "" {
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.ldap_id", nil, "")
 		}
 	}
 
 	if *o.SamlSettings.Enable {
-		if len(*o.SamlSettings.IdpUrl) == 0 {
+		if len(*o.SamlSettings.IdpUrl) == 0 || !IsValidHttpUrl(*o.SamlSettings.IdpUrl) {
 			return NewLocAppError("Config.IsValid", "model.config.is_valid.saml_idp_url.app_error", nil, "")
 		}
 
@@ -927,14 +1228,6 @@ func (o *Config) IsValid() *AppError {
 			return NewLocAppError("Config.IsValid", "model.config.is_valid.saml_username_attribute.app_error", nil, "")
 		}
 
-		if len(*o.SamlSettings.FirstNameAttribute) == 0 {
-			return NewLocAppError("Config.IsValid", "model.config.is_valid.saml_first_name_attribute.app_error", nil, "")
-		}
-
-		if len(*o.SamlSettings.LastNameAttribute) == 0 {
-			return NewLocAppError("Config.IsValid", "model.config.is_valid.saml_last_name_attribute.app_error", nil, "")
-		}
-
 		if *o.SamlSettings.Verify {
 			if len(*o.SamlSettings.AssertionConsumerServiceURL) == 0 || !IsValidHttpUrl(*o.SamlSettings.AssertionConsumerServiceURL) {
 				return NewLocAppError("Config.IsValid", "model.config.is_valid.saml_assertion_consumer_service_url.app_error", nil, "")
@@ -960,6 +1253,30 @@ func (o *Config) IsValid() *AppError {
 		return NewLocAppError("Config.IsValid", "model.config.is_valid.password_length.app_error", map[string]interface{}{"MinLength": PASSWORD_MINIMUM_LENGTH, "MaxLength": PASSWORD_MAXIMUM_LENGTH}, "")
 	}
 
+	if len(o.TeamSettings.SiteName) > SITENAME_MAX_LENGTH {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.sitename_length.app_error", map[string]interface{}{"MaxLength": SITENAME_MAX_LENGTH}, "")
+	}
+
+	if *o.RateLimitSettings.MaxBurst <= 0 {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.max_burst.app_error", nil, "")
+	}
+
+	if err := o.isValidWebrtcSettings(); err != nil {
+		return err
+	}
+
+	if !(*o.ServiceSettings.ConnectionSecurity == CONN_SECURITY_NONE || *o.ServiceSettings.ConnectionSecurity == CONN_SECURITY_TLS) {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.webserver_security.app_error", nil, "")
+	}
+
+	if *o.ServiceSettings.ReadTimeout <= 0 {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.read_timeout.app_error", nil, "")
+	}
+
+	if *o.ServiceSettings.WriteTimeout <= 0 {
+		return NewLocAppError("Config.IsValid", "model.config.is_valid.write_timeout.app_error", nil, "")
+	}
+
 	return nil
 }
 
@@ -976,7 +1293,7 @@ func (o *Config) Sanitize() {
 		*o.LdapSettings.BindPassword = FAKE_SETTING
 	}
 
-	o.FileSettings.PublicLinkSalt = FAKE_SETTING
+	*o.FileSettings.PublicLinkSalt = FAKE_SETTING
 	if len(o.FileSettings.AmazonS3SecretAccessKey) > 0 {
 		o.FileSettings.AmazonS3SecretAccessKey = FAKE_SETTING
 	}
@@ -998,3 +1315,71 @@ func (o *Config) Sanitize() {
 		o.SqlSettings.DataSourceReplicas[i] = FAKE_SETTING
 	}
 }
+
+func (o *Config) defaultWebrtcSettings() {
+	if o.WebrtcSettings.Enable == nil {
+		o.WebrtcSettings.Enable = new(bool)
+		*o.WebrtcSettings.Enable = false
+	}
+
+	if o.WebrtcSettings.GatewayWebsocketUrl == nil {
+		o.WebrtcSettings.GatewayWebsocketUrl = new(string)
+		*o.WebrtcSettings.GatewayWebsocketUrl = ""
+	}
+
+	if o.WebrtcSettings.GatewayAdminUrl == nil {
+		o.WebrtcSettings.GatewayAdminUrl = new(string)
+		*o.WebrtcSettings.GatewayAdminUrl = ""
+	}
+
+	if o.WebrtcSettings.GatewayAdminSecret == nil {
+		o.WebrtcSettings.GatewayAdminSecret = new(string)
+		*o.WebrtcSettings.GatewayAdminSecret = ""
+	}
+
+	if o.WebrtcSettings.StunURI == nil {
+		o.WebrtcSettings.StunURI = new(string)
+		*o.WebrtcSettings.StunURI = ""
+	}
+
+	if o.WebrtcSettings.TurnURI == nil {
+		o.WebrtcSettings.TurnURI = new(string)
+		*o.WebrtcSettings.TurnURI = ""
+	}
+
+	if o.WebrtcSettings.TurnUsername == nil {
+		o.WebrtcSettings.TurnUsername = new(string)
+		*o.WebrtcSettings.TurnUsername = ""
+	}
+
+	if o.WebrtcSettings.TurnSharedKey == nil {
+		o.WebrtcSettings.TurnSharedKey = new(string)
+		*o.WebrtcSettings.TurnSharedKey = ""
+	}
+}
+
+func (o *Config) isValidWebrtcSettings() *AppError {
+	if *o.WebrtcSettings.Enable {
+		if len(*o.WebrtcSettings.GatewayWebsocketUrl) == 0 || !IsValidWebsocketUrl(*o.WebrtcSettings.GatewayWebsocketUrl) {
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.webrtc_gateway_ws_url.app_error", nil, "")
+		} else if len(*o.WebrtcSettings.GatewayAdminUrl) == 0 || !IsValidHttpUrl(*o.WebrtcSettings.GatewayAdminUrl) {
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.webrtc_gateway_admin_url.app_error", nil, "")
+		} else if len(*o.WebrtcSettings.GatewayAdminSecret) == 0 {
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.webrtc_gateway_admin_secret.app_error", nil, "")
+		} else if len(*o.WebrtcSettings.StunURI) != 0 && !IsValidTurnOrStunServer(*o.WebrtcSettings.StunURI) {
+			return NewLocAppError("Config.IsValid", "model.config.is_valid.webrtc_stun_uri.app_error", nil, "")
+		} else if len(*o.WebrtcSettings.TurnURI) != 0 {
+			if !IsValidTurnOrStunServer(*o.WebrtcSettings.TurnURI) {
+				return NewLocAppError("Config.IsValid", "model.config.is_valid.webrtc_turn_uri.app_error", nil, "")
+			}
+			if len(*o.WebrtcSettings.TurnUsername) == 0 {
+				return NewLocAppError("Config.IsValid", "model.config.is_valid.webrtc_turn_username.app_error", nil, "")
+			} else if len(*o.WebrtcSettings.TurnSharedKey) == 0 {
+				return NewLocAppError("Config.IsValid", "model.config.is_valid.webrtc_turn_shared_key.app_error", nil, "")
+			}
+
+		}
+	}
+
+	return nil
+}

vendor/github.com/mattermost/platform/model/file.go

@@ -14,8 +14,8 @@ var (
 )
 
 type FileUploadResponse struct {
-	Filenames []string `json:"filenames"`
+	FileInfos []*FileInfo `json:"file_infos"`
-	ClientIds []string `json:"client_ids"`
+	ClientIds []string    `json:"client_ids"`
 }
 
 func FileUploadResponseFromJson(data io.Reader) *FileUploadResponse {

vendor/github.com/mattermost/platform/model/file_info.go

@@ -6,54 +6,31 @@ package model
 import (
 	"bytes"
 	"encoding/json"
+	"image"
 	"image/gif"
 	"io"
 	"mime"
 	"path/filepath"
+	"strings"
 )
 
 type FileInfo struct {
-	Filename        string `json:"filename"`
+	Id              string `json:"id"`
-	Size            int    `json:"size"`
+	CreatorId       string `json:"user_id"`
+	PostId          string `json:"post_id,omitempty"`
+	CreateAt        int64  `json:"create_at"`
+	UpdateAt        int64  `json:"update_at"`
+	DeleteAt        int64  `json:"delete_at"`
+	Path            string `json:"-"` // not sent back to the client
+	ThumbnailPath   string `json:"-"` // not sent back to the client
+	PreviewPath     string `json:"-"` // not sent back to the client
+	Name            string `json:"name"`
 	Extension       string `json:"extension"`
+	Size            int64  `json:"size"`
 	MimeType        string `json:"mime_type"`
-	HasPreviewImage bool   `json:"has_preview_image"`
+	Width           int    `json:"width,omitempty"`
-}
+	Height          int    `json:"height,omitempty"`
-
+	HasPreviewImage bool   `json:"has_preview_image,omitempty"`
-func GetInfoForBytes(filename string, data []byte) (*FileInfo, *AppError) {
-	size := len(data)
-
-	var mimeType string
-	extension := filepath.Ext(filename)
-	isImage := IsFileExtImage(extension)
-	if isImage {
-		mimeType = GetImageMimeType(extension)
-	} else {
-		mimeType = mime.TypeByExtension(extension)
-	}
-
-	if extension != "" && extension[0] == '.' {
-		// the client expects a file extension without the leading period
-		extension = extension[1:]
-	}
-
-	hasPreviewImage := isImage
-	if mimeType == "image/gif" {
-		// just show the gif itself instead of a preview image for animated gifs
-		if gifImage, err := gif.DecodeAll(bytes.NewReader(data)); err != nil {
-			return nil, NewLocAppError("GetInfoForBytes", "model.file_info.get.gif.app_error", nil, "filename="+filename)
-		} else {
-			hasPreviewImage = len(gifImage.Image) == 1
-		}
-	}
-
-	return &FileInfo{
-		Filename:        filename,
-		Size:            size,
-		Extension:       extension,
-		MimeType:        mimeType,
-		HasPreviewImage: hasPreviewImage,
-	}, nil
 }
 
 func (info *FileInfo) ToJson() string {
@@ -75,3 +52,123 @@ func FileInfoFromJson(data io.Reader) *FileInfo {
 		return &info
 	}
 }
+
+func FileInfosToJson(infos []*FileInfo) string {
+	b, err := json.Marshal(infos)
+	if err != nil {
+		return ""
+	} else {
+		return string(b)
+	}
+}
+
+func FileInfosFromJson(data io.Reader) []*FileInfo {
+	decoder := json.NewDecoder(data)
+
+	var infos []*FileInfo
+	if err := decoder.Decode(&infos); err != nil {
+		return nil
+	} else {
+		return infos
+	}
+}
+
+func (o *FileInfo) PreSave() {
+	if o.Id == "" {
+		o.Id = NewId()
+	}
+
+	if o.CreateAt == 0 {
+		o.CreateAt = GetMillis()
+		o.UpdateAt = o.CreateAt
+	}
+}
+
+func (o *FileInfo) IsValid() *AppError {
+	if len(o.Id) != 26 {
+		return NewLocAppError("FileInfo.IsValid", "model.file_info.is_valid.id.app_error", nil, "")
+	}
+
+	if len(o.CreatorId) != 26 {
+		return NewLocAppError("FileInfo.IsValid", "model.file_info.is_valid.user_id.app_error", nil, "id="+o.Id)
+	}
+
+	if len(o.PostId) != 0 && len(o.PostId) != 26 {
+		return NewLocAppError("FileInfo.IsValid", "model.file_info.is_valid.post_id.app_error", nil, "id="+o.Id)
+	}
+
+	if o.CreateAt == 0 {
+		return NewLocAppError("FileInfo.IsValid", "model.file_info.is_valid.create_at.app_error", nil, "id="+o.Id)
+	}
+
+	if o.UpdateAt == 0 {
+		return NewLocAppError("FileInfo.IsValid", "model.file_info.is_valid.update_at.app_error", nil, "id="+o.Id)
+	}
+
+	if o.Path == "" {
+		return NewLocAppError("FileInfo.IsValid", "model.file_info.is_valid.path.app_error", nil, "id="+o.Id)
+	}
+
+	return nil
+}
+
+func (o *FileInfo) IsImage() bool {
+	return strings.HasPrefix(o.MimeType, "image")
+}
+
+func GetInfoForBytes(name string, data []byte) (*FileInfo, *AppError) {
+	info := &FileInfo{
+		Name: name,
+		Size: int64(len(data)),
+	}
+	var err *AppError
+
+	extension := strings.ToLower(filepath.Ext(name))
+	info.MimeType = mime.TypeByExtension(extension)
+
+	if extension != "" && extension[0] == '.' {
+		// The client expects a file extension without the leading period
+		info.Extension = extension[1:]
+	} else {
+		info.Extension = extension
+	}
+
+	if info.IsImage() {
+		// Only set the width and height if it's actually an image that we can understand
+		if config, _, err := image.DecodeConfig(bytes.NewReader(data)); err == nil {
+			info.Width = config.Width
+			info.Height = config.Height
+
+			if info.MimeType == "image/gif" {
+				// Just show the gif itself instead of a preview image for animated gifs
+				if gifConfig, err := gif.DecodeAll(bytes.NewReader(data)); err != nil {
+					// Still return the rest of the info even though it doesn't appear to be an actual gif
+					info.HasPreviewImage = true
+					err = NewLocAppError("GetInfoForBytes", "model.file_info.get.gif.app_error", nil, "name="+name)
+				} else {
+					info.HasPreviewImage = len(gifConfig.Image) == 1
+				}
+			} else {
+				info.HasPreviewImage = true
+			}
+		}
+	}
+
+	return info, err
+}
+
+func GetEtagForFileInfos(infos []*FileInfo) string {
+	if len(infos) == 0 {
+		return Etag()
+	}
+
+	var maxUpdateAt int64
+
+	for _, info := range infos {
+		if info.UpdateAt > maxUpdateAt {
+			maxUpdateAt = info.UpdateAt
+		}
+	}
+
+	return Etag(infos[0].PostId, maxUpdateAt)
+}

vendor/github.com/mattermost/platform/model/incoming_webhook.go

@@ -6,6 +6,7 @@ package model
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"io"
 	"regexp"
 	"strings"
@@ -233,7 +234,7 @@ func expandAnnouncements(i *IncomingWebhookRequest) {
 				for _, field := range fields {
 					f := field.(map[string]interface{})
 					if f["value"] != nil {
-						f["value"] = expandAnnouncement(f["value"].(string))
+						f["value"] = expandAnnouncement(fmt.Sprintf("%v", f["value"]))
 					}
 				}
 			}

vendor/github.com/mattermost/platform/model/initial_load.go

@@ -9,14 +9,13 @@ import (
 )
 
 type InitialLoad struct {
-	User           *User             `json:"user"`
+	User        *User             `json:"user"`
-	TeamMembers    []*TeamMember     `json:"team_members"`
+	TeamMembers []*TeamMember     `json:"team_members"`
-	Teams          []*Team           `json:"teams"`
+	Teams       []*Team           `json:"teams"`
-	DirectProfiles map[string]*User  `json:"direct_profiles"`
+	Preferences Preferences       `json:"preferences"`
-	Preferences    Preferences       `json:"preferences"`
+	ClientCfg   map[string]string `json:"client_cfg"`
-	ClientCfg      map[string]string `json:"client_cfg"`
+	LicenseCfg  map[string]string `json:"license_cfg"`
-	LicenseCfg     map[string]string `json:"license_cfg"`
+	NoAccounts  bool              `json:"no_accounts"`
-	NoAccounts     bool              `json:"no_accounts"`
 }
 
 func (me *InitialLoad) ToJson() string {

vendor/github.com/mattermost/platform/model/job.go

@@ -84,6 +84,12 @@ func (task *ScheduledTask) Cancel() {
 	removeTaskByName(task.Name)
 }
 
+// Executes the task immediatly. A recurring task will be run regularally after interval.
+func (task *ScheduledTask) Execute() {
+	task.function()
+	task.timer.Reset(task.Interval)
+}
+
 func (task *ScheduledTask) String() string {
 	return fmt.Sprintf(
 		"%s\nInterval: %s\nRecurring: %t\n",

vendor/github.com/mattermost/platform/model/license.go

@@ -35,13 +35,34 @@ type Features struct {
 	Users                *int  `json:"users"`
 	LDAP                 *bool `json:"ldap"`
 	MFA                  *bool `json:"mfa"`
-	GoogleSSO            *bool `json:"google_sso"`
+	GoogleOAuth          *bool `json:"google_oauth"`
+	Office365OAuth       *bool `json:"office365_oauth"`
 	Compliance           *bool `json:"compliance"`
+	Cluster              *bool `json:"cluster"`
+	Metrics              *bool `json:"metrics"`
 	CustomBrand          *bool `json:"custom_brand"`
 	MHPNS                *bool `json:"mhpns"`
 	SAML                 *bool `json:"saml"`
 	PasswordRequirements *bool `json:"password_requirements"`
-	FutureFeatures       *bool `json:"future_features"`
+	// after we enabled more features for webrtc we'll need to control them with this
+	FutureFeatures *bool `json:"future_features"`
+}
+
+func (f *Features) ToMap() map[string]interface{} {
+	return map[string]interface{}{
+		"ldap":         *f.LDAP,
+		"mfa":          *f.MFA,
+		"google":       *f.GoogleOAuth,
+		"office365":    *f.Office365OAuth,
+		"compliance":   *f.Compliance,
+		"cluster":      *f.Cluster,
+		"metrics":      *f.Metrics,
+		"custom_brand": *f.CustomBrand,
+		"mhpns":        *f.MHPNS,
+		"saml":         *f.SAML,
+		"password":     *f.PasswordRequirements,
+		"future":       *f.FutureFeatures,
+	}
 }
 
 func (f *Features) SetDefaults() {
@@ -65,9 +86,14 @@ func (f *Features) SetDefaults() {
 		*f.MFA = *f.FutureFeatures
 	}
 
-	if f.GoogleSSO == nil {
+	if f.GoogleOAuth == nil {
-		f.GoogleSSO = new(bool)
+		f.GoogleOAuth = new(bool)
-		*f.GoogleSSO = *f.FutureFeatures
+		*f.GoogleOAuth = *f.FutureFeatures
+	}
+
+	if f.Office365OAuth == nil {
+		f.Office365OAuth = new(bool)
+		*f.Office365OAuth = *f.FutureFeatures
 	}
 
 	if f.Compliance == nil {
@@ -75,6 +101,16 @@ func (f *Features) SetDefaults() {
 		*f.Compliance = *f.FutureFeatures
 	}
 
+	if f.Cluster == nil {
+		f.Cluster = new(bool)
+		*f.Cluster = *f.FutureFeatures
+	}
+
+	if f.Metrics == nil {
+		f.Metrics = new(bool)
+		*f.Metrics = *f.FutureFeatures
+	}
+
 	if f.CustomBrand == nil {
 		f.CustomBrand = new(bool)
 		*f.CustomBrand = *f.FutureFeatures

vendor/github.com/mattermost/platform/model/message.go

@@ -1,61 +0,0 @@
-// Copyright (c) 2015 Mattermost, Inc. All Rights Reserved.
-// See License.txt for license information.
-
-package model
-
-import (
-	"encoding/json"
-	"io"
-)
-
-const (
-	ACTION_TYPING             = "typing"
-	ACTION_POSTED             = "posted"
-	ACTION_POST_EDITED        = "post_edited"
-	ACTION_POST_DELETED       = "post_deleted"
-	ACTION_CHANNEL_DELETED    = "channel_deleted"
-	ACTION_CHANNEL_VIEWED     = "channel_viewed"
-	ACTION_DIRECT_ADDED       = "direct_added"
-	ACTION_NEW_USER           = "new_user"
-	ACTION_LEAVE_TEAM         = "leave_team"
-	ACTION_USER_ADDED         = "user_added"
-	ACTION_USER_REMOVED       = "user_removed"
-	ACTION_PREFERENCE_CHANGED = "preference_changed"
-	ACTION_EPHEMERAL_MESSAGE  = "ephemeral_message"
-)
-
-type Message struct {
-	TeamId    string            `json:"team_id"`
-	ChannelId string            `json:"channel_id"`
-	UserId    string            `json:"user_id"`
-	Action    string            `json:"action"`
-	Props     map[string]string `json:"props"`
-}
-
-func (m *Message) Add(key string, value string) {
-	m.Props[key] = value
-}
-
-func NewMessage(teamId string, channelId string, userId string, action string) *Message {
-	return &Message{TeamId: teamId, ChannelId: channelId, UserId: userId, Action: action, Props: make(map[string]string)}
-}
-
-func (o *Message) ToJson() string {
-	b, err := json.Marshal(o)
-	if err != nil {
-		return ""
-	} else {
-		return string(b)
-	}
-}
-
-func MessageFromJson(data io.Reader) *Message {
-	decoder := json.NewDecoder(data)
-	var o Message
-	err := decoder.Decode(&o)
-	if err == nil {
-		return &o
-	} else {
-		return nil
-	}
-}

vendor/github.com/mattermost/platform/model/oauth.go

@@ -25,8 +25,10 @@ type OAuthApp struct {
 	ClientSecret string      `json:"client_secret"`
 	Name         string      `json:"name"`
 	Description  string      `json:"description"`
+	IconURL      string      `json:"icon_url"`
 	CallbackUrls StringArray `json:"callback_urls"`
 	Homepage     string      `json:"homepage"`
+	IsTrusted    bool        `json:"is_trusted"`
 }
 
 // IsValid validates the app and returns an error if it isn't configured
@@ -61,7 +63,13 @@ func (a *OAuthApp) IsValid() *AppError {
 		return NewLocAppError("OAuthApp.IsValid", "model.oauth.is_valid.callback.app_error", nil, "app_id="+a.Id)
 	}
 
-	if len(a.Homepage) == 0 || len(a.Homepage) > 256 {
+	for _, callback := range a.CallbackUrls {
+		if !IsValidHttpUrl(callback) {
+			return NewLocAppError("OAuthApp.IsValid", "model.oauth.is_valid.callback.app_error", nil, "")
+		}
+	}
+
+	if len(a.Homepage) == 0 || len(a.Homepage) > 256 || !IsValidHttpUrl(a.Homepage) {
 		return NewLocAppError("OAuthApp.IsValid", "model.oauth.is_valid.homepage.app_error", nil, "app_id="+a.Id)
 	}
 
@@ -69,6 +77,12 @@ func (a *OAuthApp) IsValid() *AppError {
 		return NewLocAppError("OAuthApp.IsValid", "model.oauth.is_valid.description.app_error", nil, "app_id="+a.Id)
 	}
 
+	if len(a.IconURL) > 0 {
+		if len(a.IconURL) > 512 || !IsValidHttpUrl(a.IconURL) {
+			return NewLocAppError("OAuthApp.IsValid", "model.oauth.is_valid.icon_url.app_error", nil, "app_id="+a.Id)
+		}
+	}
+
 	return nil
 }
 
@@ -85,10 +99,6 @@ func (a *OAuthApp) PreSave() {
 
 	a.CreateAt = GetMillis()
 	a.UpdateAt = a.CreateAt
-
-	if len(a.ClientSecret) > 0 {
-		a.ClientSecret = HashPassword(a.ClientSecret)
-	}
 }
 
 // PreUpdate should be run before updating the app in the db.
@@ -157,3 +167,23 @@ func OAuthAppMapFromJson(data io.Reader) map[string]*OAuthApp {
 		return nil
 	}
 }
+
+func OAuthAppListToJson(l []*OAuthApp) string {
+	b, err := json.Marshal(l)
+	if err != nil {
+		return ""
+	} else {
+		return string(b)
+	}
+}
+
+func OAuthAppListFromJson(data io.Reader) []*OAuthApp {
+	decoder := json.NewDecoder(data)
+	var o []*OAuthApp
+	err := decoder.Decode(&o)
+	if err == nil {
+		return o
+	} else {
+		return nil
+	}
+}