Socket Mode support

examples/socketmode/socketmode.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/client.go

@@ -0,0 +1,118 @@
+package slacksocketmode
+
+import (
+	"encoding/json"
+	"github.com/slack-go/slack"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type ConnectedEvent struct {
+	ConnectionCount int // 1 = first time, 2 = second time
+	Info            *slack.SocketModeConnection
+}
+
+type DebugInfo struct {
+	// Host is the name of the host name on the Slack end, that can be something like `applink-7fc4fdbb64-4x5xq`
+	Host string `json:"host"`
+
+	// `hello` type only
+	BuildNumber               int `json:"build_number"`
+	ApproximateConnectionTime int `json:"approximate_connection_time"`
+}
+
+type ConnectionInfo struct {
+	AppID string `json:"app_id"`
+}
+
+type SocketModeMessagePayload struct {
+	Event json.RawMessage `json:"´event"`
+}
+
+// ClientEvent is the event sent to the consumer of Client
+type ClientEvent struct {
+	Type string
+	Data interface{}
+
+	// Request is the json-decoded raw WebSocket message that is received via the Slack Socket Mode
+	// WebSocket connection.
+	Request *Request
+}
+
+// Client allows allows programs to communicate with the
+// [Events API](https://api.slack.com/events-api) over WebSocket.
+//
+// The implementation is highly inspired by https://www.npmjs.com/package/@slack/socket-mode,
+// but the structure and the design has been adapted as much as possible to that of our RTM client for consistency
+// within the library.
+//
+// You can instantiate the socket mode client with
+// Client's New() or NewSocketModeClientWithOptions(*SocketModeClientOptions)
+type Client struct {
+	// Client is the main API, embedded
+	slack.Client
+
+	idGen        slack.IDGenerator
+	pingInterval time.Duration
+
+	// pingDeadman must be intiailized in New()
+	pingDeadman *time.Timer
+
+	// Connection life-cycle
+	conn                *websocket.Conn
+	IncomingEvents      chan ClientEvent
+	socketModeResponses chan *Response
+	killChannel         chan bool
+	disconnected        chan struct{}
+	disconnectedm       *sync.Once
+
+	// UserDetails upon connection
+	info *slack.SocketModeConnection
+
+	// dialer is a gorilla/websocket Dialer. If nil, use the default
+	// Dialer.
+	dialer *websocket.Dialer
+
+	// mu is mutex used to prevent RTM connection race conditions
+	mu *sync.Mutex
+
+	wsWriteMu *sync.Mutex
+
+	// connParams is a map of flags for connection parameters.
+	connParams url.Values
+}
+
+// signal that we are disconnected by closing the channel.
+// protect it with a mutex to ensure it only happens once.
+func (smc *Client) disconnect() {
+	smc.disconnectedm.Do(func() {
+		close(smc.disconnected)
+	})
+}
+
+// Disconnect and wait, blocking until a successful disconnection.
+func (smc *Client) Disconnect() error {
+	// always push into the kill channel when invoked,
+	// this lets the ManagedConnection() function properly clean up.
+	// if the buffer is full then just continue on.
+	select {
+	case smc.killChannel <- true:
+		return nil
+	case <-smc.disconnected:
+		return slack.ErrAlreadyDisconnected
+	}
+}
+
+// GetInfo returns the info structure received when calling
+// "startrtm", holding metadata needed to implement a full
+// chat client. It will be non-nil after a call to StartRTM().
+func (smc *Client) GetInfo() *slack.SocketModeConnection {
+	return smc.info
+}
+
+func (smc *Client) resetDeadman() {
+	smc.pingDeadman.Reset(deadmanDuration(smc.pingInterval))
+}

slacksocketmode/deadman.go

@@ -0,0 +1,7 @@
+package slacksocketmode
+
+import "time"
+
+func deadmanDuration(d time.Duration) time.Duration {
+	return d * 4
+}

slacksocketmode/event.go

@@ -0,0 +1,6 @@
+package slacksocketmode
+
+type ErrorWriteFailed struct {
+	Cause    error
+	Response *Response
+}

slacksocketmode/request.go

@@ -0,0 +1,38 @@
+package slacksocketmode
+
+import "encoding/json"
+
+// Request maps to the content of each WebSocket message received via a Socket Mode WebSocket connection
+//
+// We call this a "request" rather than e.g. a WebSocket message or an Socket Mode "event" following python-slack-sdk:
+//
+//   https://github.com/slackapi/python-slack-sdk/blob/3f1c4c6e27bf7ee8af57699b2543e6eb7848bcf9/slack_sdk/socket_mode/request.py#L6
+//
+// We know that node-slack-sdk calls it an "event", that makes it hard for us to distinguish our client's own event
+// that wraps both internal events and Socket Mode "events", vs node-slack-sdk's is for the latter only.
+//
+// https://github.com/slackapi/node-slack-sdk/blob/main/packages/socket-mode/src/SocketModeClient.ts#L537
+type Request struct {
+	Type string `json:"type"`
+
+	// `hello` type only
+	NumConnections int            `json:"num_connections"`
+	ConnectionInfo ConnectionInfo `json:"connection_info"`
+
+	// `disconnect` type only
+
+	// Reason can be "warning" or else
+	Reason string `json:"reason"`
+
+	// `hello` and `disconnect` types only
+	DebugInfo DebugInfo `json:"debug_info"`
+
+	// `events_api` type only
+	EnvelopeID string `json:"envelope_id"`
+	// TODO Can it really be a non-object type?
+	// See https://github.com/slackapi/python-slack-sdk/blob/3f1c4c6e27bf7ee8af57699b2543e6eb7848bcf9/slack_sdk/socket_mode/request.py#L26-L31
+	Payload                json.RawMessage `json:"payload"`
+	AcceptsResponsePayload bool            `json:"accepts_response_payload"`
+	RetryAttempt           int             `json:"retry_attempt"`
+	RetryReason            string          `json:"retry_reason"`
+}