slack-bot-manager 0.1.0pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 211a6a7bd9fb7a2557d3c946bbf495ae562a186d
+  data.tar.gz: e2fc191df9ff401007c4f8e8e35bd2cf18302a8a
+SHA512:
+  metadata.gz: 0349d9425e90b8b68ea9b890b2edcf255ef2896f1a7e5606c5d1fc9c8146111c0698b88ab7416ee132399b96dfbd02369e5f84bde88a181b1c69e932e08de48d
+  data.tar.gz: 128445cb7a39b80058bddd14fa89e0abda4db055fddb345ce330643a0c970c1fefbad3ec9978ebc6288226275bf1ed27625bf46b526618b5d0e7c66fbc92429f

data/.gitignore

@@ -0,0 +1,6 @@
+._*
+.DS_Store
+.env
+pkg
+Gemfile.lock
+tokens.yml

data/.gitmodules

@@ -0,0 +1,12 @@
+[submodule "examples/emoji-art-bot"]
+	path = examples/emoji-art-bot
+	url = git@github.com:goosey/emoji-art-bot.git
+[submodule "examples/downforeveryone-bot"]
+	path = examples/downforeveryone-bot
+	url = https://github.com/goosey/downforeveryone-bot
+[submodule "examples/botspotting"]
+	path = examples/botspotting
+	url = git@github.com:goosey/botspotting.git
+[submodule "examples/dm-bot"]
+	path = examples/dm-bot
+	url = git@github.com:gleuch/dm-bot.git

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+
+### Version 0.1.0 (20 Jan 2016)
+
+__**NOT YET RELEASED**__
+
+This is the first version of Slack Bot Manager, and includes
+
+* Initial public release of Slack Bot Manager - [@gleuch](https://github.com/gleuch)
+* Ability to register and remove tokens used for creating connections to Slack RTM. - [@gleuch](https://github.com/gleuch)
+* Manager system to start, stop, and monitor multiple RTM connections. - [@gleuch](https://github.com/gleuch)
+* Handle event and output logging. - [@gleuch](https://github.com/gleuch)

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2015-2016 Greg Leuch & Betaworks Studio
+
+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.

data/README.md

@@ -0,0 +1,159 @@
+# Slack Bot Manager
+
+Slack Bot Manager is a Ruby gem that allows for the management of multiple Slack RTM connections based on tokens. With only a few configuration changes, you can run a system for handling hundreds of simulatenous RTM connections for your Slack app. 
+
+
+
+## Installation
+
+While this has yet to be compiled to a Ruby gem, it can be installed from this repository within your Gemfile:
+
+`gem 'slack-bot-manager', github: 'betaworks/slack-bot-manager', branch: 'master'`
+
+__**This gem requires `redis` for tracking the status of tokens.**__
+You will need to have `redis` running for this gem to work.
+
+
+
+## Getting Started
+
+(TODO)
+
+
+
+## Running the Slack Bot Manager
+
+Once you initialize a new `SlackBotManager::Manager`, you can use the following connection and token methods to run your cool new Slack bot app.
+
+
+### Manager Connection Methods
+
+You can run a manager supporting multiple RTM connections with just __**three**__ lines!
+
+```
+botmanager = SlackBotManager::Manager.new
+botmanager.start
+botmanager.monitor
+```
+
+These are the available connecton methods:
+
+methods     | description
+------------|----------------------------------------------------------------------------------------------
+`start`     | Start connections by fetching known tokens and creating each connection
+`stop`      | Stop connections
+`restart`   | Restart connections
+`status`    | Get the status of the current manager (number of connections).
+`monitor`   | Run the manager in a continuous loop, checking for changes in connections and token statuses.
+
+
+### Token Management Methods
+
+Tokens are managed within Redis. SlackBotManager will manage and monitor these redis keys for additions, updates, and remvoals. New connections must be added into the redis `teams_key`, like so:
+
+```
+botmanager = SlackBotManager::Manager.new
+botmanager.add_token('token1', 'token2', 'token3') # takes array
+```
+
+These are the available token methods:
+
+methods                 | description
+------------------------|----------------------------------------------------------------------------
+`add_token(*tokens)`    | Add new token(s), will connect within `monitor` loop. [array]
+`remove_token(*tokens)` | Remove token(s), will disconnect within `monitor` loop. [array]
+`update_token(*tokens)` | Update token(s), will trigger update methods within `monitor` loop. [array]
+`check_token(*tokens)`  | Check the status of token(s), output status(es). [array]
+
+
+
+## Client Connections
+
+Each RTM connection handled by `SlackBotManager::Manager` is generated by `SlackBotManager::Client`. This client class assists in checking RTM (websocket) connection status, storing various attributes, and includes event listener support. 
+
+The following instance variables are accessible by Client and the included Commands module:
+
+variable      | description
+--------------|----------------------------------------------------------------------------------------
+`connection`  | `Slack::RealTime::Client`  connection
+`id`          | Team's Slack ID (ex. `T123ABC`)
+`token`       | Team's Slack access token (ex. `xoxb-123abc456def`)
+`status`      | Known connection status. (`connected`, `disconnected`, `rate_limited`, `token_revoked`)
+
+
+### Adding Event Listeners
+
+You will want to handle your own RTM event listeners to perform specific functions. This is achieved by extending the `SlackBotManager:Commands` module, which is included within the `SlackBotManager::Client` class (and access to subsequent instance variables specific to that connection).
+
+Each event must be prefixed with `on_`, e.g. `on_messsage` will handing incoming messages.
+
+```
+module SlackBotManager
+  module Commands
+    def on_hello(data)
+      puts "Connected to %s" % self.id
+    end
+
+    def on_team_join(data)
+      puts "New team member joined: %s" % data['user']['username']
+    end
+  end
+end
+```
+
+(A full list of events is available from the [Slack API docs](https://api.slack.com/rtm#events).)
+
+
+
+## Configuration
+
+### Manager configuration options
+
+setting           | description
+------------------|-----------------------------------------------------------------------------------
+`tokens_key`      | Redis key name for where tokens' status are stored. _(default: tokens:statuses)_
+`teams_key`       | Redis key name for where teams' tokens are stored. _(default: tokens:teams)_
+`check_interval`  | Interval (in seconds) for checking connections and tokens status. _(default: 5)_
+`redis`           | Define Redis connection. _(default: Redis.new)_
+`logger`          | Define the logger to use. _(default: Rails.logger or ::Logger.new(STDOUT))_
+`log_level`       | Explicity define the logger level. _(default: ::Logger::WARN)_
+`verbose`         | When true, set `log_level` to ::Logger::DEBUG. _(default: false)_
+
+You can define these configuration options as:
+
+```
+SlackBotManager::Manager.configure do |config|
+  config.redis = Redis.new(host: '0.0.0.0', port: 6379)
+  config.check_interval = 10 # in seconds
+end
+```
+
+For customization of Slack connections, including proxy, websocket ping, endpoint, user-agent, and more, check out the [slack-ruby-client README](https://github.com/dblock/slack-ruby-client/blob/master/README.md).
+
+
+
+## Examples
+
+(TODO)
+
+
+
+## History
+
+This gem will be released soon, and is based on earlier work created by [betaworks](https://betaworks.com) for [PlusPlus++](https://plusplus.chat) Slack app.
+
+Also thanks to [slack-ruby-client](https://github.com/dblock/slack-ruby-client).
+
+
+
+## Contributing
+
+See [CONTRIBUTING](CONTRIBUTING.md).
+
+
+
+## Copyright and License
+
+Copyright (c) 2016 [Greg Leuch](https://gleu.ch) & [betaworks](https://betaworks.com).
+
+Licensed under [MIT License](LICENSE.md).

data/UPGRADING.md

@@ -0,0 +1,3 @@
+# Upgrading Slack Bot Manager
+
+Since this is still in version 0.1.0, there are no upgrade notes.

data/lib/slack-bot-manager/client/base.rb

@@ -0,0 +1,89 @@
+module SlackBotManager
+  class Client
+
+    include Commands
+    include Errors
+    include Logger
+
+    attr_accessor :commands, :connection, :id, :token, :status
+    attr_accessor(*Config::CLIENT_ATTRIBUTES)
+
+    def initialize(id, token, *args)
+      options = args.extract_options!
+      @id, @token, @events, @status = id, token, options[:events] || {}, :disconnected
+
+      # Setup client and assign commands
+      @connection = Slack::RealTime::Client.new(token: @token)
+
+      # Load config options
+      SlackBotManager::Config::CLIENT_ATTRIBUTES.each do |key|
+        send("#{key}=", options[key] || SlackBotManager.config.send(key))
+      end
+
+      # Assign commands
+      self.methods.each do |n|
+        # Require methods to include on_*
+        next unless n.match(/^on_/) && self.respond_to?(n)
+        assign_event(n.to_s.gsub(/^on_/, ''), n)
+      end
+
+      connect
+    end
+
+    def connect
+      connection.start_async
+      @status = :connected
+    rescue => err
+      handle_error(err)
+    end
+
+    def disconnect(reason=:disconnected)
+      connection && connection.stop!
+    rescue => err
+      handle_error(err)
+    ensure
+      @status = reason if @status == :connected
+      remove_instance_variable(:@connection) if @connection
+    end
+
+    def connected?
+      connection && connection.started?
+    end
+
+    def disconnected?
+      !connected?
+    end
+
+
+  protected
+
+    def send_message(channel, text, *args)
+      options = args.extract_options!
+      # TODO : HANDLE CASES WHERE NEED TO POST ATTACHMENTS, SEND DMs, ETC
+      options[:channel] = channel
+      options[:text] = text
+      connection.message(options)
+    end
+
+    def assign_event(evt, evt_name)
+      connection.on(evt) do |data|
+        begin
+          send(evt_name, data) if respond_to?(evt_name)
+        rescue => err
+          handle_error(err)
+        end
+      end
+    end
+
+    # Handle different error cases
+    def handle_error(err, data=nil)
+      case determine_error_type(err)
+        when :token_revoked;  on_revoke(data)
+        when :rate_limited;   on_rate_limit(data)
+        when :closed;         on_close(data)
+        else;                 on_error(err, data)
+      end
+    end
+
+  end
+end

data/lib/slack-bot-manager/client/commands.rb

@@ -0,0 +1,26 @@
+module SlackBotManager
+  module Commands
+
+    # Handle when connection gets closed
+    def on_close(data, *args)
+      options = args.extract_options!
+      options[:code] ||= (data && data.code) || '1000'
+
+      disconnect
+      raise SlackBotManager::ConnectionRateLimited if ['1008','429'].include?(options[:code].to_s)
+    end
+
+    # Handle rate limit errors coming from web API
+    def on_revoke(data)
+      disconnect(:token_revoked)
+      raise SlackBotManager::TokenRevoked
+    end
+
+    # Handle rate limit errors coming from web API
+    def on_rate_limit(data)
+      disconnect(:rate_limited)
+      raise SlackBotManager::ConnectionRateLimited
+    end
+
+  end
+end

data/lib/slack-bot-manager/config.rb

@@ -0,0 +1,110 @@
+module SlackBotManager
+  module Config
+
+    extend self
+
+    MANAGER_ATTRIBUTES = [
+      :tokens_key,
+      :teams_key,
+      :check_interval,
+      :redis,
+      :logger,
+      :log_level,
+      :verbose
+    ]
+
+    CLIENT_ATTRIBUTES = [
+      :redis,
+      :logger,
+      :log_level,
+      :verbose
+    ]
+
+    WEB_CLIENT_ATTRIBUTES = [
+      :user_agent,
+      :proxy,
+      :ca_path,
+      :ca_file,
+      :endpoint
+    ]
+
+    RTM_CLIENT_ATTRIBUTES = [
+      :websocket_ping,
+      :websocket_proxy
+    ]
+
+    attr_accessor *Config::MANAGER_ATTRIBUTES
+    attr_accessor *Config::CLIENT_ATTRIBUTES
+    attr_accessor *Config::WEB_CLIENT_ATTRIBUTES
+    attr_accessor *Config::RTM_CLIENT_ATTRIBUTES
+
+    def reset
+      # Slack web and realtime config options
+      Slack::Web::Config.reset
+      Slack::RealTime::Config.reset
+
+      self.tokens_key = 'tokens:statuses'
+      self.teams_key = 'tokens:teams'
+      self.check_interval = 5 # seconds
+      self.redis = Redis.new
+      self.logger = defined?(Rails) ? Rails.logger : ::Logger.new(STDOUT)
+      self.log_level = ::Logger::INFO
+      self.logger.formatter = SlackBotManager::Logger::Formatter.new
+      self.verbose = false
+      self.user_agent = "Slack Bot Manager/#{SlackBotManager::VERSION} <https://github.com/betaworks/slack-bot-manager>"
+    end
+
+    # Slack Web Client config
+    Config::WEB_CLIENT_ATTRIBUTES.each do |name|
+      define_method "#{name}=" do |val|
+        Slack::Web.configure do |config|
+          config.send("#{name}=", val)
+        end
+      end
+    end
+
+    # Slack RealTime Client config
+    Config::RTM_CLIENT_ATTRIBUTES.each do |name|
+      define_method "#{name}=" do |val|
+        Slack::Web.configure do |config|
+          config.send("#{name}=", val)
+        end
+      end
+    end
+
+    def verbose=(val)
+      @verbose = val
+      self.log_level = val ? ::Logger::DEBUG : ::Logger::INFO
+    end
+
+    def logger=(log)
+      @logger = log
+
+      # Also define Slack Web client logger
+      Slack::Web.configure do |config|
+        config.logger = @logger
+      end
+    end
+
+    def log_level=(level)
+      self.logger.level = level
+    end
+
+    def log_formatter=(formatter)
+      self.logger.formatter = formatter
+    end
+
+  end
+
+  class << self
+    def configure
+      block_given? ? yield(Config) : Config
+    end
+
+    def config
+      Config
+    end
+  end
+end
+
+SlackBotManager::Config.reset

data/lib/slack-bot-manager/errors.rb

@@ -0,0 +1,50 @@
+module SlackBotManager
+
+  class ConnectionClosed < StandardError; end
+  class ConnectionRateLimited < StandardError; end
+  class InvalidToken < StandardError; end
+  class TokenAlreadyConnected < StandardError; end
+  class TokenNotConnected < StandardError; end
+  class TokenRevoked < StandardError; end
+
+
+  module Errors
+
+    # Mapping of error classes to type
+    CLASS_ERROR_TYPES = {
+      token_revoked: [
+        SlackBotManager::InvalidToken, 
+        SlackBotManager::TokenRevoked
+      ],
+      rate_limited: [
+        SlackBotManager::ConnectionRateLimited
+      ],
+      closed: [
+        SlackBotManager::ConnectionClosed,
+        Slack::RealTime::Client::ClientNotStartedError
+      ],
+    }
+
+    # Regexp mapping of error keywords to type
+    STRING_ERROR_TYPES = {
+      token_revoked: /token_revoked|account_inactive|invalid_auth/i,
+      rate_limited: /rate_limit|status 429/i,
+      closed: /closed/i,
+    }
+
+    def determine_error_type(err)
+      # Check known error types, unless string
+      CLASS_ERROR_TYPES.each{|k,v| return k if v.include?(err) } unless err.is_a?(String)
+
+      # Check string matches, as we might get code responses or capture something inside it
+      STRING_ERROR_TYPES.each{|k,v| return k if v.match(err.to_s) }
+
+      :error
+    end
+
+    def on_error(err,data=nil)
+      error(err)
+    end
+
+  end
+end

data/lib/slack-bot-manager/extend.rb

@@ -0,0 +1,19 @@
+# via https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/array/extract_options.rb
+
+# Add extract_options! used in ActiveSupport
+
+unless {}.respond_to?(:extractable_options?)
+  class Hash
+    def extractable_options?
+      instance_of?(Hash)
+    end
+  end
+end
+
+unless [].respond_to?(:extract_options!)
+  class Array
+    def extract_options!
+      last.is_a?(Hash) && last.extractable_options? ? pop : {}
+    end
+  end
+end

data/lib/slack-bot-manager/logger.rb

@@ -0,0 +1,44 @@
+module SlackBotManager
+  module Logger
+
+    def info(msg)
+      logger.info(@id) { msg }
+    end
+
+    def debug(msg)
+      logger.debug(@id) { msg }
+    end
+
+    def warning(msg)
+      logger.warn(@id) { msg }
+    end
+
+    def error(msg)
+      logger.error(@id) { msg }
+    end
+
+
+    class Formatter
+      SEVERITY_TO_COLOR_MAP   = {'DEBUG'=>'0;37', 'INFO'=>'32', 'WARN'=>'33', 'ERROR'=>'31', 'FATAL'=>'31', 'UNKNOWN'=>'37'}
+
+      def call(severity, timeat, progname, message)
+        formatted_severity = sprintf("%-5s",severity).strip
+        formatted_time = timeat.strftime("%Y-%m-%d %H:%M:%S.") << timeat.usec.to_s[0..2].rjust(3)
+        color = SEVERITY_TO_COLOR_MAP[severity]
+
+        # Handle backtrace, if any
+        msg = message.to_s
+        message.backtrace.each{|n| msg << "\n   #{n}"} if message.respond_to?(:backtrace)
+
+        [
+          "\033[0;37m#{formatted_time}\033[0m",               # Formatted time
+          "[\033[#{color}m#{formatted_severity}\033[0m]",     # Level
+          "[PID:#{$$}]",                                      # PID
+          progname && progname != '' && "(#{progname})",      # Progname (team ID), if exists
+          msg.strip                                           # Message
+        ].compact.join(' ') + "\n"
+      end
+    end
+
+  end
+end

data/lib/slack-bot-manager/manager/base.rb

@@ -0,0 +1,35 @@
+module SlackBotManager
+  class Manager
+
+    include Tokens
+    include Connection
+    include Errors
+    include Logger
+
+    attr_accessor :connections
+    attr_accessor(*Config::MANAGER_ATTRIBUTES)
+
+    def initialize(*args)
+      options = args.extract_options!
+
+      # Storage of connection keys
+      @connections = {}
+
+      # Load config options
+      SlackBotManager::Config::MANAGER_ATTRIBUTES.each do |key|
+        send("#{key}=", options[key] || SlackBotManager.config.send(key))
+      end
+    end
+
+    class << self
+      def configure
+        block_given? ? yield(config) : config
+      end
+
+      def config
+        Config
+      end
+    end
+
+  end
+end

data/lib/slack-bot-manager/manager/connection.rb

@@ -0,0 +1,167 @@
+module SlackBotManager
+  module Connection
+
+    # Monitor our connections, while connections is {...}
+    def monitor
+      while connections do
+        sleep 1 # Pause momentarily
+
+        # On occasion, check our connection statuses
+        if Time.now.to_i % check_interval == 0
+          # Get tokens and connection statuses
+          tokens_status, rtm_status = self.redis.hgetall(tokens_key), self.redis.hgetall(teams_key)
+
+          # Manage connections
+          connections.each do |cid,conn|
+            id,_s = cid.split(':')
+
+            # Remove/continue if connection is/will close or no longer connected
+            if !conn
+              warning("Removing: #{id} (Reason: rtm_not_connection)")
+              destroy(cid: cid)
+
+            elsif !conn.connected?
+              warning("Removing: #{conn.id} (Reason: #{conn.status})")
+              to_remove = ['token_revoked'].include?((conn.status || '').to_s)
+              destroy(cid: cid, remove_token: to_remove)
+
+            # Team is no longer valid, remove
+            elsif !!tokens_status[conn.id].empty?
+              warning("Removing: #{conn.id} (Reason: token_missing)")
+              destroy(cid: cid, remove_token: true)
+
+            elsif rtm_status[conn.id] == 'destroy'
+              warning("Removing: #{conn.id} (Reason: token_destroy)")
+              destroy(cid: cid)
+
+            # Kill connection if token has changed, will re-create next block below
+            elsif tokens_status[conn.id] != conn.token
+              warning("Removing: #{conn.id} (Reason: new_token)")
+              destroy(cid: cid)
+
+            # Connection should be re-created unless it is active, will update next block below
+            elsif rtm_status[conn.id] != 'active'
+              warning("Restarting: #{conn.id} (Reason: #{rtm_status[conn.id]})")
+              destroy(cid: cid)
+              self.redis.hset(tokens_key, conn.id, tokens_status[conn.id])
+            end
+          end
+
+          # Give pause before any reconnects, as destroy methods might still be processing in their threads
+          sleep 1
+
+          # Check for new tokens / reconnections (reload keys since we might modify if bad). Kill and recreate
+          tokens_status, rtm_status = self.redis.hgetall(tokens_key), self.redis.hgetall(teams_key)
+          tokens_diff = (tokens_status.keys - rtm_status.keys) + (rtm_status.keys - tokens_status.keys)
+
+          unless !!tokens_diff.empty?
+            tokens_diff.uniq.each do |id|
+              warning("Starting: #{id}")
+              destroy(id: id)
+              create(id, tokens_status[id])
+            end
+          end
+
+          info("Active Connections: [#{connections.count}]")
+        end
+      end
+    end
+
+    # Create websocket connections for active tokens
+    def start
+      # Clear RTM connections
+      self.redis.del(teams_key)
+
+      # Start a new connection for each team
+      self.redis.hgetall(tokens_key).each do |id,token|
+        create(id,token)
+      end
+    end
+
+    # Remove all connections from app, will disconnect in monitor loop
+    def stop
+      # Thread wrapped to ensure no lock issues on shutdown
+      thr = Thread.new {
+        conns = self.redis.hgetall(teams_key)
+        self.redis.pipelined do
+          conns.each{|k,v| self.redis.hset(teams_key, k, 'destroy') }
+        end
+        info("Stopped.")
+      }
+      thr.join
+    end
+
+    # Issue restart status on all RTM connections, will re-connect in monitor loop
+    def restart
+      conns = self.redis.hgetall(teams_key)
+      self.redis.pipelined do
+        conns.each{|k,v| self.redis.hset(teams_key, k, 'restart') }
+      end
+    end
+
+    # Get status of current connections
+    def status
+      info("Active connections: [#{self.redis.hgetall(teams_key).count}]")
+    end
+
+
+  protected
+
+    # Find the connection based on id and has active connection
+    def find_connection(id)
+      connections.each do |cid,conn|
+        return (conn.connected? ? conn : false) if conn && conn.id == id
+      end
+      false
+    end
+
+    # Create new connection if not exist
+    def create(id,token)
+      raise SlackBotManager::TokenAlreadyConnected if find_connection(id)
+
+      # Create connection
+      conn = SlackBotManager::Client.new(id, token)
+
+      # Add to connections using a uniq token, as we might have connection closing and opening with same id
+      if conn
+        cid = [id,Time.now.to_i].join(':')
+        connections[cid] = conn
+        info("Connected: #{id} (Connection: #{cid})")
+        self.redis.hset(teams_key, id, 'active')
+      end
+    rescue => err
+      on_error(err)
+    end
+
+    # Disconnect from a RTM connection
+    def destroy(*args)
+      options = args.extract_options!
+
+      # Get connection or search for connection with cid
+      if options[:cid]
+        conn, cid = connections[options[:cid]], options[:cid]
+      elsif options[:id]
+        conn, cid = find_connection(options[:id])
+      end
+      return false unless conn && cid
+
+      # Kill connection, remove from connection keys, and delete from connections list
+      begin
+        thr = Thread.new {
+          self.redis.hdel(teams_key, conn.id) rescue nil
+
+          if options[:remove_token]
+            self.redis.hdel(tokens_key, conn.id) rescue nil
+          end
+        }
+        thr.join
+        connections.delete(cid)
+      rescue => err
+        nil
+      end
+    rescue => err
+      on_error(err)
+    end
+
+  end
+end

data/lib/slack-bot-manager/manager/tokens.rb

@@ -0,0 +1,87 @@
+module SlackBotManager
+  module Tokens
+
+    # Add token(s) to be connected
+    def add_token(*tokens)
+      tokens.each do |token|
+        begin
+          team_info = check_token_status(token)
+
+          # Add to token list
+          self.redis.hset(self.tokens_key, team_info['team_id'], token)
+        rescue => err
+          on_error(err)
+        end
+      end
+    end
+
+    # Remove token(s) and connection(s)
+    def remove_token(*tokens)
+      tokens.each do |token|
+        begin
+          id = get_id_from_token(token) # As token should be in list
+          raise SlackBotManager::InvalidToken if !!id.empty?
+
+          # Delete from token and connections list
+          self.redis.hdel(self.tokens_key, id)
+          self.redis.hdel(self.teams_key, id)
+        rescue => err
+          on_error(err)
+        end
+      end
+    end
+
+    # Remove all tokens
+    def clear_tokens
+      remove_token(*self.redis.hgetall(self.tokens_key).values)
+    rescue => err
+      nil
+    end
+
+    # Restart token connection(s)
+    def update_token(*tokens)
+      tokens.each do |token|
+        begin
+          id = get_id_from_token(token) # As token should be in list
+          raise SlackBotManager::InvalidToken if !!id.empty?
+
+          # Issue reset command
+          self.redis.hset(self.teams_key, id, 'restart')
+        rescue => err
+          on_error(err)
+        end
+      end
+    end
+
+    # Check token connection(s)
+    def check_token(*tokens)
+      rtm_keys = self.redis.hgetall(self.teams_key)
+
+      tokens.each do |token|
+        begin
+          team_info = check_token_status(token)
+
+          info("Team #{team_info['team_id']} :: #{rtm_keys[ team_info['team_id'] ] || 'not_connected'}")
+        rescue => err
+          on_error(err)
+        end
+      end
+    end
+
+  protected
+
+    # Get team id from Slack. (also test if token is valid)
+    def check_token_status(token)
+      info = Slack::Web::Client.new(token: token).auth_test
+      raise SlackBotManager::InvalidToken unless info && info['ok']
+      info
+    end
+
+    # Given a token, get id from tokens list
+    def get_id_from_token(token)
+      self.redis.hgetall(self.tokens_key).each{|id,t| return id if t == token }
+      false
+    end
+
+  end
+end

data/lib/slack-bot-manager/version.rb

@@ -0,0 +1,3 @@
+module SlackBotManager
+  VERSION = '0.1.0pre1'
+end

data/lib/slack-bot-manager.rb

@@ -0,0 +1,20 @@
+# Core requirements
+require 'logger'
+require 'redis'
+require 'slack-ruby-client'
+
+# core components
+require 'slack-bot-manager/version'
+require 'slack-bot-manager/errors'
+require 'slack-bot-manager/logger'
+require 'slack-bot-manager/config'
+require 'slack-bot-manager/extend.rb'
+
+# bot client connection
+require 'slack-bot-manager/client/commands'
+require 'slack-bot-manager/client/base'
+
+# connection manager
+require 'slack-bot-manager/manager/connection'
+require 'slack-bot-manager/manager/tokens'
+require 'slack-bot-manager/manager/base'

data/slack-bot-manager.gemspec

@@ -0,0 +1,29 @@
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'slack-bot-manager/version'
+
+Gem::Specification.new do |s|
+  s.name = 'slack-bot-manager'
+  s.version = SlackBotManager::VERSION
+  s.authors = ['Greg Leuch']
+  s.email = ['greg@betaworks.com', 'contact@gleu.ch']
+  s.platform = Gem::Platform::RUBY
+  s.required_rubygems_version = '>= 1.3.6'
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ['lib']
+  s.homepage = 'http://github.com/betaworks/slack-bot-manager'
+  s.licenses = ['MIT']
+  s.summary = 'Slack RealTime API client connection manager.'
+
+  s.add_dependency 'slack-ruby-client', '>=0.5.1'
+  s.add_dependency 'faye-websocket', '>=0.10.0'
+  s.add_dependency 'redis', '>=3.2.2'
+
+  # s.add_development_dependency 'erubis'
+  # s.add_development_dependency 'json-schema'
+  # s.add_development_dependency 'rake'
+  # s.add_development_dependency 'rspec'
+  # s.add_development_dependency 'vcr'
+  # s.add_development_dependency 'webmock'
+  # s.add_development_dependency 'rubocop', '0.35.0'
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: slack-bot-manager
+version: !ruby/object:Gem::Version
+  version: 0.1.0pre1
+platform: ruby
+authors:
+- Greg Leuch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slack-ruby-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+description: 
+email:
+- greg@betaworks.com
+- contact@gleu.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".rspec"
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- UPGRADING.md
+- lib/slack-bot-manager.rb
+- lib/slack-bot-manager/client/base.rb
+- lib/slack-bot-manager/client/commands.rb
+- lib/slack-bot-manager/config.rb
+- lib/slack-bot-manager/errors.rb
+- lib/slack-bot-manager/extend.rb
+- lib/slack-bot-manager/logger.rb
+- lib/slack-bot-manager/manager/base.rb
+- lib/slack-bot-manager/manager/connection.rb
+- lib/slack-bot-manager/manager/tokens.rb
+- lib/slack-bot-manager/version.rb
+- slack-bot-manager.gemspec
+homepage: http://github.com/betaworks/slack-bot-manager
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Slack RealTime API client connection manager.
+test_files: []