Socket Mode support

examples/socketmode/events.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"fmt"
+	"github.com/slack-go/slack/slacksocketmode"
+	"log"
+	"os"
+	"strings"
+
+	"github.com/slack-go/slack"
+	"github.com/slack-go/slack/slackevents"
+)
+
+func main() {
+	appToken := os.Getenv("SLACK_APP_TOKEN")
+	if appToken == "" {
+
+	}
+
+	if !strings.HasPrefix(appToken, "xapp-") {
+		fmt.Fprintf(os.Stderr, "SLACK_APP_TOKEN must have the prefix \"xapp-\".")
+	}
+
+	botToken := os.Getenv("SLACK_BOT_TOKEN")
+	if botToken == "" {
+		fmt.Fprintf(os.Stderr, "SLACK_BOT_TOKEN must be set.\n")
+		os.Exit(1)
+	}
+
+	if !strings.HasPrefix(botToken, "xoxb-") {
+		fmt.Fprintf(os.Stderr, "SLACK_APP_TOKEN must have the prefix \"xoxb-\".")
+	}
+
+	api := slack.New(
+		botToken,
+		slack.OptionDebug(true),
+		slack.OptionLog(log.New(os.Stdout, "slack-bot: ", log.Lshortfile|log.LstdFlags)),
+		slack.OptionAppLevelToken(appToken),
+	)
+
+	client := slacksocketmode.New(api)
+
+	go func() {
+		for evt := range client.IncomingEvents {
+			eventsAPIEvent, ok := evt.Data.(slackevents.EventsAPIEvent)
+			if !ok {
+				fmt.Printf("Ignored %+v\n", evt)
+
+				continue
+			}
+
+			fmt.Printf("Event Received: %+v\n", eventsAPIEvent)
+
+			switch evt.Type {
+			case slackevents.CallbackEvent:
+				innerEvent := eventsAPIEvent.InnerEvent
+				switch ev := innerEvent.Data.(type) {
+				case *slackevents.AppMentionEvent:
+					_, _, err := api.PostMessage(ev.Channel, slack.MsgOptionText("Yes, hello.", false))
+					if err != nil {
+						fmt.Printf("failed posting message: %v", err)
+					}
+				}
+			case slackevents.MemberJoinedChannel:
+				ev := eventsAPIEvent.Data.(*slackevents.MemberJoinedChannelEvent)
+
+				fmt.Printf("user %q joined to channel %q", ev.User, ev.Channel)
+			case slackevents.AppMention:
+				ev := eventsAPIEvent.Data.(*slackevents.AppMentionEvent)
+
+				_, _, err := api.PostMessage(ev.Channel, slack.MsgOptionText("hey yo!", false))
+				if err != nil {
+					fmt.Printf("failed posting message: %v", err)
+				}
+			}
+		}
+	}()
+
+	client.Run()
+}

backoff.go → internal/backoff/backoff.go

@@ -1,4 +1,4 @@
-package slack
+package backoff
 
 import (
 	"math/rand"
@@ -11,7 +11,7 @@ import (
 // call to Duration() it is multiplied by Factor.  It is capped at
 // Max. It returns to Min on every call to Reset().  Used in
 // conjunction with the time package.
-type backoff struct {
+type Backoff struct {
 	attempts int
 	// Initial value to scale out
 	Initial time.Duration
@@ -23,7 +23,7 @@ type backoff struct {
 
 // Returns the current value of the counter and then multiplies it
 // Factor
-func (b *backoff) Duration() (dur time.Duration) {
+func (b *Backoff) Duration() (dur time.Duration) {
 	// Zero-values are nonsensical, so we use
 	// them to apply defaults
 	if b.Max == 0 {
@@ -52,6 +52,11 @@ func (b *backoff) Duration() (dur time.Duration) {
 }
 
 //Resets the current value of the counter back to Min
-func (b *backoff) Reset() {
+func (b *Backoff) Reset() {
 	b.attempts = 0
 }
+
+// Attempts returns the number of attempts that we had done so far
+func (b *Backoff) Attempts() int {
+	return b.attempts
+}

internal/misc/misc.go

@@ -0,0 +1,29 @@
+package misc
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// StatusCodeError represents an http response error.
+// type httpStatusCode interface { HTTPStatusCode() int } to handle it.
+type StatusCodeError struct {
+	Code   int
+	Status string
+}
+
+func (t StatusCodeError) Error() string {
+	return fmt.Sprintf("slack server error: %s", t.Status)
+}
+
+func (t StatusCodeError) HTTPStatusCode() int {
+	return t.Code
+}
+
+func (t StatusCodeError) Retryable() bool {
+	if t.Code >= 500 || t.Code == http.StatusTooManyRequests {
+		return true
+	}
+	return false
+}
+

misc.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/slack-go/slack/internal/misc"
 	"io"
 	"io/ioutil"
 	"mime"
@@ -42,28 +43,6 @@ func (t SlackResponse) Err() error {
 	return errors.New(t.Error)
 }
 
-// StatusCodeError represents an http response error.
-// type httpStatusCode interface { HTTPStatusCode() int } to handle it.
-type statusCodeError struct {
-	Code   int
-	Status string
-}
-
-func (t statusCodeError) Error() string {
-	return fmt.Sprintf("slack server error: %s", t.Status)
-}
-
-func (t statusCodeError) HTTPStatusCode() int {
-	return t.Code
-}
-
-func (t statusCodeError) Retryable() bool {
-	if t.Code >= 500 || t.Code == http.StatusTooManyRequests {
-		return true
-	}
-	return false
-}
-
 // RateLimitedError represents the rate limit respond from slack
 type RateLimitedError struct {
 	RetryAfter time.Duration
@@ -312,7 +291,7 @@ func checkStatusCode(resp *http.Response, d Debug) error {
 	// Slack seems to send an HTML body along with 5xx error codes. Don't parse it.
 	if resp.StatusCode != http.StatusOK {
 		logResponse(resp, d)
-		return statusCodeError{Code: resp.StatusCode, Status: resp.Status}
+		return misc.StatusCodeError{Code: resp.StatusCode, Status: resp.Status}
 	}
 
 	return nil

misc_test.go

@@ -2,6 +2,7 @@ package slack
 
 import (
 	"context"
+	"github.com/slack-go/slack/internal/misc"
 	"log"
 	"net/http"
 	"net/url"
@@ -92,8 +93,8 @@ func TestParseResponseInvalidToken(t *testing.T) {
 func TestRetryable(t *testing.T) {
 	for _, e := range []error{
 		&RateLimitedError{},
-		statusCodeError{Code: http.StatusInternalServerError},
-		statusCodeError{Code: http.StatusTooManyRequests},
+		misc.StatusCodeError{Code: http.StatusInternalServerError},
+		misc.StatusCodeError{Code: http.StatusTooManyRequests},
 	} {
 		r, ok := e.(slackutilsx.Retryable)
 		if !ok {

slacksocketmode/socket_mode.go

@@ -0,0 +1,83 @@
+package slacksocketmode
+
+import (
+	"context"
+	"github.com/slack-go/slack"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+const (
+	socketModeEventTypeHello      = "hello"
+
+	websocketDefaultTimeout = 10 * time.Second
+	defaultMaxPingInterval  = 30 * time.Second
+)
+
+// Open calls the "apps.connection.open" endpoint and returns the provided URL and the full Info block.
+//
+// To have a fully managed Websocket connection, use `New`, and call `Run()` on it.
+func (smc *Client) Open() (info *slack.SocketModeConnection, websocketURL string, err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), websocketDefaultTimeout)
+	defer cancel()
+
+	return smc.StartSocketModeContext(ctx)
+}
+
+// Option options for the managed Client.
+type Option func(client *Client)
+
+// OptionDialer takes a gorilla websocket Dialer and uses it as the
+// Dialer when opening the websocket for the RTM connection.
+func OptionDialer(d *websocket.Dialer) Option {
+	return func(smc *Client) {
+		smc.dialer = d
+	}
+}
+
+// OptionPingInterval determines how often we expect Slack to deliver WebSocket ping to us.
+// If no ping is delivered to us within this interval after the last ping, we assumes the WebSocket connection
+// is dead and needs to be reconnected.
+func OptionPingInterval(d time.Duration) Option {
+	return func(rtm *Client) {
+		rtm.pingInterval = d
+		rtm.resetDeadman()
+	}
+}
+
+// OptionConnParams installs parameters to embed into the connection URL.
+func OptionConnParams(connParams url.Values) Option {
+	return func(smc *Client) {
+		smc.connParams = connParams
+	}
+}
+
+// NewRTM returns a RTM, which provides a fully managed connection to
+// Slack's websocket-based Real-Time Messaging protocol.
+func New(api *slack.Client, options ...Option) *Client {
+	result := &Client{
+		Client:           *api,
+		IncomingEvents:   make(chan SocketModeEvent, 50),
+		outgoingMessages: make(chan slack.OutgoingMessage, 20),
+		pingInterval:     defaultMaxPingInterval,
+		pingDeadman:      time.NewTimer(deadmanDuration(defaultMaxPingInterval)),
+		killChannel:      make(chan bool),
+		disconnected:     make(chan struct{}),
+		disconnectedm:    &sync.Once{},
+		idGen:            slack.NewSafeID(1),
+		mu:               &sync.Mutex{},
+	}
+
+	for _, opt := range options {
+		opt(result)
+	}
+
+	return result
+}
+
+func deadmanDuration(d time.Duration) time.Duration {
+	return d * 4
+}