From 250b3bb5795240d5ebdab5416ab99dbc41be734b Mon Sep 17 00:00:00 2001 From: Wim Date: Sun, 1 Mar 2020 20:59:19 +0100 Subject: Use upstream slack-go/slack again (#1018) --- .../nlopes/slack/websocket_managed_conn.go | 581 --------------------- 1 file changed, 581 deletions(-) delete mode 100644 vendor/github.com/nlopes/slack/websocket_managed_conn.go (limited to 'vendor/github.com/nlopes/slack/websocket_managed_conn.go') diff --git a/vendor/github.com/nlopes/slack/websocket_managed_conn.go b/vendor/github.com/nlopes/slack/websocket_managed_conn.go deleted file mode 100644 index dbbf682d..00000000 --- a/vendor/github.com/nlopes/slack/websocket_managed_conn.go +++ /dev/null @@ -1,581 +0,0 @@ -package slack - -import ( - "encoding/json" - "fmt" - "io" - "net/http" - stdurl "net/url" - "reflect" - "time" - - "github.com/gorilla/websocket" - "github.com/nlopes/slack/internal/errorsx" - "github.com/nlopes/slack/internal/timex" -) - -// ManageConnection can be called on a Slack RTM instance returned by the -// NewRTM method. It will connect to the slack RTM API and handle all incoming -// and outgoing events. If a connection fails then it will attempt to reconnect -// and will notify any listeners through an error event on the IncomingEvents -// channel. -// -// If the connection ends and the disconnect was unintentional then this will -// attempt to reconnect. -// -// This should only be called once per slack API! Otherwise expect undefined -// behavior. -// -// The defined error events are located in websocket_internals.go. -func (rtm *RTM) ManageConnection() { - var ( - err error - info *Info - conn *websocket.Conn - ) - - for connectionCount := 0; ; connectionCount++ { - // start trying to connect - // the returned err is already passed onto the IncomingEvents channel - if info, conn, err = rtm.connect(connectionCount, rtm.useRTMStart); err != nil { - // when the connection is unsuccessful its fatal, and we need to bail out. - rtm.Debugf("Failed to connect with RTM on try %d: %s", connectionCount, err) - rtm.disconnect() - return - } - - // lock to prevent data races with Disconnect particularly around isConnected - // and conn. - rtm.mu.Lock() - rtm.conn = conn - rtm.info = info - rtm.mu.Unlock() - - rtm.IncomingEvents <- RTMEvent{"connected", &ConnectedEvent{ - ConnectionCount: connectionCount, - Info: info, - }} - - rtm.Debugf("RTM connection succeeded on try %d", connectionCount) - - rawEvents := make(chan json.RawMessage) - // we're now connected so we can set up listeners - go rtm.handleIncomingEvents(rawEvents) - // this should be a blocking call until the connection has ended - rtm.handleEvents(rawEvents) - - select { - case <-rtm.disconnected: - // after handle events returns we need to check if we're disconnected - // when this happens we need to cleanup the newly created connection. - if err = conn.Close(); err != nil { - rtm.Debugln("failed to close conn on disconnected RTM", err) - } - return - default: - // otherwise continue and run the loop again to reconnect - } - } -} - -// connect attempts to connect to the slack websocket API. It handles any -// errors that occur while connecting and will return once a connection -// has been successfully opened. -// If useRTMStart is false then it uses rtm.connect to create the connection, -// otherwise it uses rtm.start. -func (rtm *RTM) connect(connectionCount int, useRTMStart bool) (*Info, *websocket.Conn, error) { - const ( - errInvalidAuth = "invalid_auth" - errInactiveAccount = "account_inactive" - errMissingAuthToken = "not_authed" - ) - - // used to provide exponential backoff wait time with jitter before trying - // to connect to slack again - boff := &backoff{ - Max: 5 * time.Minute, - } - - for { - var ( - backoff time.Duration - ) - - // send connecting event - rtm.IncomingEvents <- RTMEvent{"connecting", &ConnectingEvent{ - Attempt: boff.attempts + 1, - ConnectionCount: connectionCount, - }} - - // attempt to start the connection - info, conn, err := rtm.startRTMAndDial(useRTMStart) - if err == nil { - return info, conn, nil - } - - // check for fatal errors - switch err.Error() { - case errInvalidAuth, errInactiveAccount, errMissingAuthToken: - rtm.Debugf("invalid auth when connecting with RTM: %s", err) - rtm.IncomingEvents <- RTMEvent{"invalid_auth", &InvalidAuthEvent{}} - return nil, nil, err - default: - } - - switch actual := err.(type) { - case statusCodeError: - if actual.Code == http.StatusNotFound { - rtm.Debugf("invalid auth when connecting with RTM: %s", err) - rtm.IncomingEvents <- RTMEvent{"invalid_auth", &InvalidAuthEvent{}} - return nil, nil, err - } - case *RateLimitedError: - backoff = actual.RetryAfter - default: - } - - backoff = timex.Max(backoff, boff.Duration()) - // any other errors are treated as recoverable and we try again after - // sending the event along the IncomingEvents channel - rtm.IncomingEvents <- RTMEvent{"connection_error", &ConnectionErrorEvent{ - Attempt: boff.attempts, - Backoff: backoff, - ErrorObj: err, - }} - - // get time we should wait before attempting to connect again - rtm.Debugf("reconnection %d failed: %s reconnecting in %v\n", boff.attempts, err, backoff) - - // wait for one of the following to occur, - // backoff duration has elapsed, killChannel is signalled, or - // the rtm finishes disconnecting. - select { - case <-time.After(backoff): // retry after the backoff. - case intentional := <-rtm.killChannel: - if intentional { - rtm.killConnection(intentional, ErrRTMDisconnected) - return nil, nil, ErrRTMDisconnected - } - case <-rtm.disconnected: - return nil, nil, ErrRTMDisconnected - } - } -} - -// startRTMAndDial attempts to connect to the slack websocket. If useRTMStart is true, -// then it returns the full information returned by the "rtm.start" method on the -// slack API. Else it uses the "rtm.connect" method to connect -func (rtm *RTM) startRTMAndDial(useRTMStart bool) (info *Info, _ *websocket.Conn, err error) { - var ( - url string - ) - - if useRTMStart { - rtm.Debugf("Starting RTM") - info, url, err = rtm.StartRTM() - } else { - rtm.Debugf("Connecting to RTM") - info, url, err = rtm.ConnectRTM() - } - if err != nil { - rtm.Debugf("Failed to start or connect to RTM: %s", err) - return nil, nil, err - } - - // install connection parameters - u, err := stdurl.Parse(url) - if err != nil { - return nil, nil, err - } - u.RawQuery = rtm.connParams.Encode() - url = u.String() - - rtm.Debugf("Dialing to websocket on url %s", url) - // Only use HTTPS for connections to prevent MITM attacks on the connection. - upgradeHeader := http.Header{} - upgradeHeader.Add("Origin", "https://api.slack.com") - dialer := websocket.DefaultDialer - if rtm.dialer != nil { - dialer = rtm.dialer - } - conn, _, err := dialer.Dial(url, upgradeHeader) - if err != nil { - rtm.Debugf("Failed to dial to the websocket: %s", err) - return nil, nil, err - } - return info, conn, err -} - -// killConnection stops the websocket connection and signals to all goroutines -// that they should cease listening to the connection for events. -// -// This should not be called directly! Instead a boolean value (true for -// intentional, false otherwise) should be sent to the killChannel on the RTM. -func (rtm *RTM) killConnection(intentional bool, cause error) (err error) { - rtm.Debugln("killing connection", cause) - - if rtm.conn != nil { - err = rtm.conn.Close() - } - - rtm.IncomingEvents <- RTMEvent{"disconnected", &DisconnectedEvent{Intentional: intentional, Cause: cause}} - - if intentional { - rtm.disconnect() - } - - return err -} - -// handleEvents is a blocking function that handles all events. This sends -// pings when asked to (on rtm.forcePing) and upon every given elapsed -// interval. This also sends outgoing messages that are received from the RTM's -// outgoingMessages channel. This also handles incoming raw events from the RTM -// rawEvents channel. -func (rtm *RTM) handleEvents(events chan json.RawMessage) { - ticker := time.NewTicker(rtm.pingInterval) - defer ticker.Stop() - for { - select { - // catch "stop" signal on channel close - case intentional := <-rtm.killChannel: - _ = rtm.killConnection(intentional, errorsx.String("signaled")) - return - // detect when the connection is dead. - case <-rtm.pingDeadman.C: - _ = rtm.killConnection(false, ErrRTMDeadman) - return - // send pings on ticker interval - case <-ticker.C: - if err := rtm.ping(); err != nil { - _ = rtm.killConnection(false, err) - return - } - case <-rtm.forcePing: - if err := rtm.ping(); err != nil { - _ = rtm.killConnection(false, err) - return - } - // listen for messages that need to be sent - case msg := <-rtm.outgoingMessages: - rtm.sendOutgoingMessage(msg) - // listen for incoming messages that need to be parsed - case rawEvent := <-events: - switch rtm.handleRawEvent(rawEvent) { - case rtmEventTypeGoodbye: - // kill the connection, but DO NOT RETURN, a follow up kill signal will - // be sent that still needs to be processed. this duplication is because - // the event reader restarts once it emits the goodbye event. - // unlike the other cases in this function a final read will be triggered - // against the connection which will emit a kill signal. if we return early - // this kill signal will be processed by the next connection. - _ = rtm.killConnection(false, ErrRTMGoodbye) - default: - } - } - } -} - -// handleIncomingEvents monitors the RTM's opened websocket for any incoming -// events. It pushes the raw events into the channel. -// -// This will stop executing once the RTM's when a fatal error is detected, or -// a disconnect occurs. -func (rtm *RTM) handleIncomingEvents(events chan json.RawMessage) { - for { - if err := rtm.receiveIncomingEvent(events); err != nil { - select { - case rtm.killChannel <- false: - case <-rtm.disconnected: - } - return - } - } -} - -func (rtm *RTM) sendWithDeadline(msg interface{}) error { - // set a write deadline on the connection - if err := rtm.conn.SetWriteDeadline(time.Now().Add(10 * time.Second)); err != nil { - return err - } - if err := rtm.conn.WriteJSON(msg); err != nil { - return err - } - // remove write deadline - return rtm.conn.SetWriteDeadline(time.Time{}) -} - -// sendOutgoingMessage sends the given OutgoingMessage to the slack websocket. -// -// It does not currently detect if a outgoing message fails due to a disconnect -// and instead lets a future failed 'PING' detect the failed connection. -func (rtm *RTM) sendOutgoingMessage(msg OutgoingMessage) { - rtm.Debugln("Sending message:", msg) - if len([]rune(msg.Text)) > MaxMessageTextLength { - rtm.IncomingEvents <- RTMEvent{"outgoing_error", &MessageTooLongEvent{ - Message: msg, - MaxLength: MaxMessageTextLength, - }} - return - } - - if err := rtm.sendWithDeadline(msg); err != nil { - rtm.IncomingEvents <- RTMEvent{"outgoing_error", &OutgoingErrorEvent{ - Message: msg, - ErrorObj: err, - }} - } -} - -// ping sends a 'PING' message to the RTM's websocket. If the 'PING' message -// fails to send then this returns an error signifying that the connection -// should be considered disconnected. -// -// This does not handle incoming 'PONG' responses but does store the time of -// each successful 'PING' send so latency can be detected upon a 'PONG' -// response. -func (rtm *RTM) ping() error { - id := rtm.idGen.Next() - rtm.Debugln("Sending PING ", id) - msg := &Ping{ID: id, Type: "ping", Timestamp: time.Now().Unix()} - - if err := rtm.sendWithDeadline(msg); err != nil { - rtm.Debugf("RTM Error sending 'PING %d': %s", id, err.Error()) - return err - } - return nil -} - -// receiveIncomingEvent attempts to receive an event from the RTM's websocket. -// This will block until a frame is available from the websocket. -// If the read from the websocket results in a fatal error, this function will return non-nil. -func (rtm *RTM) receiveIncomingEvent(events chan json.RawMessage) error { - event := json.RawMessage{} - err := rtm.conn.ReadJSON(&event) - - // check if the connection was closed. - if websocket.IsUnexpectedCloseError(err) { - return err - } - - switch { - case err == io.ErrUnexpectedEOF: - // EOF's don't seem to signify a failed connection so instead we ignore - // them here and detect a failed connection upon attempting to send a - // 'PING' message - - // trigger a 'PING' to detect potential websocket disconnect - select { - case rtm.forcePing <- true: - case <-rtm.disconnected: - } - case err != nil: - // All other errors from ReadJSON come from NextReader, and should - // kill the read loop and force a reconnect. - rtm.IncomingEvents <- RTMEvent{"incoming_error", &IncomingEventError{ - ErrorObj: err, - }} - - return err - case len(event) == 0: - rtm.Debugln("Received empty event") - default: - rtm.Debugln("Incoming Event:", string(event)) - select { - case events <- event: - case <-rtm.disconnected: - rtm.Debugln("disonnected while attempting to send raw event") - } - } - - return nil -} - -// handleRawEvent takes a raw JSON message received from the slack websocket -// and handles the encoded event. -// returns the event type of the message. -func (rtm *RTM) handleRawEvent(rawEvent json.RawMessage) string { - event := &Event{} - err := json.Unmarshal(rawEvent, event) - if err != nil { - rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}} - return "" - } - - switch event.Type { - case rtmEventTypeAck: - rtm.handleAck(rawEvent) - case rtmEventTypeHello: - rtm.IncomingEvents <- RTMEvent{"hello", &HelloEvent{}} - case rtmEventTypePong: - rtm.handlePong(rawEvent) - case rtmEventTypeGoodbye: - // just return the event type up for goodbye, will be handled by caller. - default: - rtm.handleEvent(event.Type, rawEvent) - } - - return event.Type -} - -// handleAck handles an incoming 'ACK' message. -func (rtm *RTM) handleAck(event json.RawMessage) { - ack := &AckMessage{} - if err := json.Unmarshal(event, ack); err != nil { - rtm.Debugln("RTM Error unmarshalling 'ack' event:", err) - rtm.Debugln(" -> Erroneous 'ack' event:", string(event)) - return - } - - if ack.Ok { - rtm.IncomingEvents <- RTMEvent{"ack", ack} - } else if ack.RTMResponse.Error != nil { - // As there is no documentation for RTM error-codes, this - // identification of a rate-limit warning is very brittle. - if ack.RTMResponse.Error.Code == -1 && ack.RTMResponse.Error.Msg == "slow down, too many messages..." { - rtm.IncomingEvents <- RTMEvent{"ack_error", &RateLimitEvent{}} - } else { - rtm.IncomingEvents <- RTMEvent{"ack_error", &AckErrorEvent{ack.Error}} - } - } else { - rtm.IncomingEvents <- RTMEvent{"ack_error", &AckErrorEvent{fmt.Errorf("ack decode failure")}} - } -} - -// handlePong handles an incoming 'PONG' message which should be in response to -// a previously sent 'PING' message. This is then used to compute the -// connection's latency. -func (rtm *RTM) handlePong(event json.RawMessage) { - var ( - p Pong - ) - - rtm.resetDeadman() - - if err := json.Unmarshal(event, &p); err != nil { - rtm.Client.log.Println("RTM Error unmarshalling 'pong' event:", err) - return - } - - latency := time.Since(time.Unix(p.Timestamp, 0)) - rtm.IncomingEvents <- RTMEvent{"latency_report", &LatencyReport{Value: latency}} -} - -// handleEvent is the "default" response to an event that does not have a -// special case. It matches the command's name to a mapping of defined events -// and then sends the corresponding event struct to the IncomingEvents channel. -// If the event type is not found or the event cannot be unmarshalled into the -// correct struct then this sends an UnmarshallingErrorEvent to the -// IncomingEvents channel. -func (rtm *RTM) handleEvent(typeStr string, event json.RawMessage) { - v, exists := EventMapping[typeStr] - if !exists { - rtm.Debugf("RTM Error - received unmapped event %q: %s\n", typeStr, string(event)) - err := fmt.Errorf("RTM Error: Received unmapped event %q: %s", typeStr, string(event)) - rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}} - return - } - t := reflect.TypeOf(v) - recvEvent := reflect.New(t).Interface() - err := json.Unmarshal(event, recvEvent) - if err != nil { - rtm.Debugf("RTM Error, could not unmarshall event %q: %s\n", typeStr, string(event)) - err := fmt.Errorf("RTM Error: Could not unmarshall event %q: %s", typeStr, string(event)) - rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}} - return - } - rtm.IncomingEvents <- RTMEvent{typeStr, recvEvent} -} - -// EventMapping holds a mapping of event names to their corresponding struct -// implementations. The structs should be instances of the unmarshalling -// target for the matching event type. -var EventMapping = map[string]interface{}{ - "message": MessageEvent{}, - "presence_change": PresenceChangeEvent{}, - "user_typing": UserTypingEvent{}, - - "channel_marked": ChannelMarkedEvent{}, - "channel_created": ChannelCreatedEvent{}, - "channel_joined": ChannelJoinedEvent{}, - "channel_left": ChannelLeftEvent{}, - "channel_deleted": ChannelDeletedEvent{}, - "channel_rename": ChannelRenameEvent{}, - "channel_archive": ChannelArchiveEvent{}, - "channel_unarchive": ChannelUnarchiveEvent{}, - "channel_history_changed": ChannelHistoryChangedEvent{}, - - "dnd_updated": DNDUpdatedEvent{}, - "dnd_updated_user": DNDUpdatedEvent{}, - - "im_created": IMCreatedEvent{}, - "im_open": IMOpenEvent{}, - "im_close": IMCloseEvent{}, - "im_marked": IMMarkedEvent{}, - "im_history_changed": IMHistoryChangedEvent{}, - - "group_marked": GroupMarkedEvent{}, - "group_open": GroupOpenEvent{}, - "group_joined": GroupJoinedEvent{}, - "group_left": GroupLeftEvent{}, - "group_close": GroupCloseEvent{}, - "group_rename": GroupRenameEvent{}, - "group_archive": GroupArchiveEvent{}, - "group_unarchive": GroupUnarchiveEvent{}, - "group_history_changed": GroupHistoryChangedEvent{}, - - "file_created": FileCreatedEvent{}, - "file_shared": FileSharedEvent{}, - "file_unshared": FileUnsharedEvent{}, - "file_public": FilePublicEvent{}, - "file_private": FilePrivateEvent{}, - "file_change": FileChangeEvent{}, - "file_deleted": FileDeletedEvent{}, - "file_comment_added": FileCommentAddedEvent{}, - "file_comment_edited": FileCommentEditedEvent{}, - "file_comment_deleted": FileCommentDeletedEvent{}, - - "pin_added": PinAddedEvent{}, - "pin_removed": PinRemovedEvent{}, - - "star_added": StarAddedEvent{}, - "star_removed": StarRemovedEvent{}, - - "reaction_added": ReactionAddedEvent{}, - "reaction_removed": ReactionRemovedEvent{}, - - "pref_change": PrefChangeEvent{}, - - "team_join": TeamJoinEvent{}, - "team_rename": TeamRenameEvent{}, - "team_pref_change": TeamPrefChangeEvent{}, - "team_domain_change": TeamDomainChangeEvent{}, - "team_migration_started": TeamMigrationStartedEvent{}, - - "manual_presence_change": ManualPresenceChangeEvent{}, - - "user_change": UserChangeEvent{}, - - "emoji_changed": EmojiChangedEvent{}, - - "commands_changed": CommandsChangedEvent{}, - - "email_domain_changed": EmailDomainChangedEvent{}, - - "bot_added": BotAddedEvent{}, - "bot_changed": BotChangedEvent{}, - - "accounts_changed": AccountsChangedEvent{}, - - "reconnect_url": ReconnectUrlEvent{}, - - "member_joined_channel": MemberJoinedChannelEvent{}, - "member_left_channel": MemberLeftChannelEvent{}, - - "subteam_created": SubteamCreatedEvent{}, - "subteam_self_added": SubteamSelfAddedEvent{}, - "subteam_self_removed": SubteamSelfRemovedEvent{}, - "subteam_updated": SubteamUpdatedEvent{}, - - "desktop_notification": DesktopNotificationEvent{}, -} -- cgit v1.2.3