1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
package socketmode
import (
"context"
"log"
"os"
"time"
"github.com/gorilla/websocket"
"github.com/slack-go/slack"
)
// EventType is the type of events that are emitted by scoketmode.Client.
// You receive and handle those events from a socketmode.Client.Events channel.
// Those event types does not necessarily match 1:1 to those of Slack Events API events.
type EventType string
const (
// The following request types are the types of requests sent from Slack via Socket Mode WebSocket connection
// and handled internally by the socketmode.Client.
// The consumer of socketmode.Client will never see it.
RequestTypeHello = "hello"
RequestTypeEventsAPI = "events_api"
RequestTypeDisconnect = "disconnect"
RequestTypeSlashCommands = "slash_commands"
RequestTypeInteractive = "interactive"
// The following event types are for events emitted by socketmode.Client itself and
// does not originate from Slack.
EventTypeConnecting = EventType("connecting")
EventTypeInvalidAuth = EventType("invalid_auth")
EventTypeConnectionError = EventType("connection_error")
EventTypeConnected = EventType("connected")
EventTypeIncomingError = EventType("incoming_error")
EventTypeErrorWriteFailed = EventType("write_error")
EventTypeErrorBadMessage = EventType("error_bad_message")
//
// The following event types are guaranteed to not change unless Slack changes
//
EventTypeHello = EventType("hello")
EventTypeDisconnect = EventType("disconnect")
EventTypeEventsAPI = EventType("events_api")
EventTypeInteractive = EventType("interactive")
EventTypeSlashCommand = EventType("slash_commands")
websocketDefaultTimeout = 10 * time.Second
defaultMaxPingInterval = 30 * time.Second
)
// Open calls the "apps.connections.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)
}
// OpenContext calls the "apps.connections.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) OpenContext(ctx context.Context) (info *slack.SocketModeConnection, websocketURL string, err error) {
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 Socket Mode 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(smc *Client) {
smc.maxPingInterval = d
}
}
// OptionDebug enable debugging for the client
func OptionDebug(b bool) func(*Client) {
return func(c *Client) {
c.debug = b
}
}
// OptionLog set logging for client.
func OptionLog(l logger) func(*Client) {
return func(c *Client) {
c.log = internalLog{logger: l}
}
}
// New returns a Socket Mode client which provides a fully managed connection to
// Slack's Websocket-based Socket Mode.
func New(api *slack.Client, options ...Option) *Client {
result := &Client{
Client: *api,
Events: make(chan Event, 50),
socketModeResponses: make(chan *Response, 20),
maxPingInterval: defaultMaxPingInterval,
log: log.New(os.Stderr, "slack-go/slack/socketmode", log.LstdFlags|log.Lshortfile),
}
for _, opt := range options {
opt(result)
}
return result
}
|
