slack-bot-manager 0.1.0pre1 → 0.1.0pre2

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

@@ -1,24 +1,23 @@
 module SlackBotManager
   module Config
-
     extend self
 
     MANAGER_ATTRIBUTES = [
       :tokens_key,
       :teams_key,
       :check_interval,
-      :redis,
+      :storage_method,
+      :storage_options,
       :logger,
       :log_level,
       :verbose
-    ]
+    ].freeze
 
     CLIENT_ATTRIBUTES = [
-      :redis,
       :logger,
       :log_level,
       :verbose
-    ]
+    ].freeze
 
     WEB_CLIENT_ATTRIBUTES = [
       :user_agent,
@@ -26,17 +25,28 @@ module SlackBotManager
       :ca_path,
       :ca_file,
       :endpoint
-    ]
+    ].freeze
 
     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
+    ].freeze
+
+    RTM_CLIENT_METHODS = [
+      :url,
+      :team,
+      :self,
+      :users,
+      :channels,
+      :groups,
+      :ims,
+      :bots
+    ].freeze
+
+    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
@@ -46,7 +56,8 @@ module SlackBotManager
       self.tokens_key = 'tokens:statuses'
       self.teams_key = 'tokens:teams'
       self.check_interval = 5 # seconds
-      self.redis = Redis.new
+      self.storage_method = method(:detect_storage_method)
+      self.storage_options = {}
       self.logger = defined?(Rails) ? Rails.logger : ::Logger.new(STDOUT)
       self.log_level = ::Logger::INFO
       self.logger.formatter = SlackBotManager::Logger::Formatter.new
@@ -72,6 +83,10 @@ module SlackBotManager
       end
     end
 
+    def storage_method
+      (val = @storage_method).respond_to?(:call) ? val.call : val
+    end
+
     def verbose=(val)
       @verbose = val
       self.log_level = val ? ::Logger::DEBUG : ::Logger::INFO
@@ -94,6 +109,19 @@ module SlackBotManager
       self.logger.formatter = formatter
     end
 
+    private
+
+    def detect_storage_method
+      [:Redis, :Dalli].each do |storage_method|
+        begin
+          return SlackBotManager::Storage.const_get(storage_method)
+        rescue LoadError, NameError
+          false
+        end
+      end
+
+      fail NoStorageMethod, 'Missing storage method. Add redis or dalli to your Gemfile.'
+    end
   end
 
   class << self

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

@@ -1,19 +1,17 @@
 module SlackBotManager
-
   class ConnectionClosed < StandardError; end
   class ConnectionRateLimited < StandardError; end
   class InvalidToken < StandardError; end
+  class NoStorageMethod < 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::InvalidToken,
         SlackBotManager::TokenRevoked
       ],
       rate_limited: [
@@ -22,29 +20,28 @@ module SlackBotManager
       closed: [
         SlackBotManager::ConnectionClosed,
         Slack::RealTime::Client::ClientNotStartedError
-      ],
-    }
+      ]
+    }.freeze
 
     # 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,
-    }
+      closed: /closed/i
+    }.freeze
 
     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)
+      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) }
+      # Check string matches for 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)
+    def on_error(err, _ = nil)
       error(err)
     end
-
   end
 end

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

@@ -1,7 +1,6 @@
 # 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?
@@ -16,4 +15,16 @@ unless [].respond_to?(:extract_options!)
       last.is_a?(Hash) && last.extractable_options? ? pop : {}
     end
   end
-end
+end
+
+# Allow removing methods from Slack::RealTime::Client
+module Slack
+  module RealTime
+    class Client
+      def off(type)
+        type = type.to_s
+        callbacks.delete(type) if callbacks.key?(type)
+      end
+    end
+  end
+end

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

@@ -1,6 +1,5 @@
 module SlackBotManager
   module Logger
-
     def info(msg)
       logger.info(@id) { msg }
     end
@@ -17,28 +16,33 @@ module SlackBotManager
       logger.error(@id) { msg }
     end
 
-
     class Formatter
-      SEVERITY_TO_COLOR_MAP   = {'DEBUG'=>'0;37', 'INFO'=>'32', 'WARN'=>'33', 'ERROR'=>'31', 'FATAL'=>'31', 'UNKNOWN'=>'37'}
+      SEVERITY_TO_COLOR_MAP = {
+        'DEBUG' => '0;37',
+        'INFO' => '32',
+        'WARN' => '33',
+        'ERROR' => '31',
+        'FATAL' => '31',
+        'UNKNOWN' => '37'
+      }.freeze
 
       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)
+        formatted_severity = format('%-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)
+        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
+          "[PID:#{$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

@@ -1,12 +1,11 @@
 module SlackBotManager
   class Manager
-
     include Tokens
     include Connection
     include Errors
     include Logger
 
-    attr_accessor :connections
+    attr_accessor :connections, :storage
     attr_accessor(*Config::MANAGER_ATTRIBUTES)
 
     def initialize(*args)
@@ -19,8 +18,12 @@ module SlackBotManager
       SlackBotManager::Config::MANAGER_ATTRIBUTES.each do |key|
         send("#{key}=", options[key] || SlackBotManager.config.send(key))
       end
+
+      # Set token storage method
+      @storage = storage_method.new(storage_options)
     end
 
+    # Include config helpers
     class << self
       def configure
         block_given? ? yield(config) : config
@@ -30,6 +33,5 @@ module SlackBotManager
         Config
       end
     end
-
   end
 end

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

@@ -1,133 +1,137 @@
 module SlackBotManager
   module Connection
-
     # Monitor our connections, while connections is {...}
     def monitor
-      while connections do
+      while connections
         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
+        next unless Time.now.to_i % check_interval == 0
+
+        # Get tokens and connection statuses
+        tokens_status = storage.get_all(tokens_key)
+        rtm_status = storage.get_all(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].nil? || 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 below
+          elsif tokens_status[conn.id] != conn.token
+            warning("Removing: #{conn.id} (Reason: new_token)")
+            destroy(cid: cid)
+
+          # Connection should re-create unless active, will update below
+          elsif rtm_status[conn.id] != 'active'
+            reason = rtm_status[conn.id] || '(unknown)'
+            warning("Restarting: #{conn.id} (Reason: #{reason})")
+            destroy(cid: cid)
+            storage.set(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
+        # Pause before reconnects, as destroy might be processing in 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)
+        # Check for new tokens / reconnections
+        # (reload keys since we might modify if bad). Kill and recreate
+        tokens_status = storage.get_all(tokens_key)
+        rtm_status = storage.get_all(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
+        unless tokens_diff.empty?
+          tokens_diff.uniq.each do |id|
+            warning("Starting: #{id}")
+            destroy(id: id)
+            create(id, tokens_status[id])
           end
-
-          info("Active Connections: [#{connections.count}]")
         end
+
+        info("Active Connections: [#{connections.count}]")
       end
     end
 
     # Create websocket connections for active tokens
     def start
       # Clear RTM connections
-      self.redis.del(teams_key)
+      storage.delete_all(teams_key)
 
       # Start a new connection for each team
-      self.redis.hgetall(tokens_key).each do |id,token|
-        create(id,token)
+      storage.get_all(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') }
+      thr = Thread.new do
+        conns = storage.get_all(teams_key)
+        storage.pipeline do
+          conns.each { |k, _| storage.set(teams_key, k, 'destroy') }
         end
-        info("Stopped.")
-      }
+        info('Stopped.')
+      end
       thr.join
     end
 
-    # Issue restart status on all RTM connections, will re-connect in monitor loop
+    # 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') }
+      conns = storage.get_all(teams_key)
+      storage.pipeline do
+        conns.each { |k, _| storage.set(teams_key, k, 'restart') }
       end
     end
 
     # Get status of current connections
     def status
-      info("Active connections: [#{self.redis.hgetall(teams_key).count}]")
+      info("Active connections: [#{storage.get_all(teams_key).count}]")
     end
 
-
-  protected
+    protected
 
     # Find the connection based on id and has active connection
     def find_connection(id)
-      connections.each do |cid,conn|
+      connections.each do |_, 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)
+    def create(id, token)
+      fail SlackBotManager::TokenAlreadyConnected if find_connection(id)
 
       # Create connection
-      conn = SlackBotManager::Client.new(id, token)
+      conn = SlackBotManager::Client.new(token)
+      conn.connect
 
-      # Add to connections using a uniq token, as we might have connection closing and opening with same id
+      # Add to connections using a uniq token
       if conn
-        cid = [id,Time.now.to_i].join(':')
+        cid = [id, Time.now.to_i].join(':')
         connections[cid] = conn
         info("Connected: #{id} (Connection: #{cid})")
-        self.redis.hset(teams_key, id, 'active')
+        storage.set(teams_key, id, 'active')
       end
     rescue => err
       on_error(err)
@@ -139,29 +143,26 @@ module SlackBotManager
 
       # Get connection or search for connection with cid
       if options[:cid]
-        conn, cid = connections[options[:cid]], options[:cid]
+        conn = connections[options[:cid]]
+        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
+      # Kill connection, remove from keys, and delete from 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 = Thread.new do
+          storage.delete(teams_key, conn.id) rescue nil
+          storage.delete(tokens_key, conn.id) rescue nil if options[:remove_token]
+        end
         thr.join
         connections.delete(cid)
-      rescue => err
+      rescue
         nil
       end
     rescue => err
       on_error(err)
     end
-
   end
 end

data/lib/slack-bot-manager/manager/storage/dalli.rb

@@ -0,0 +1,63 @@
+require 'dalli'
+
+module SlackBotManager
+  module Storage
+    class Dalli
+      attr_accessor :connection
+
+      def initialize(options)
+        if options.is_a?(Dalli)
+          @connecton = options
+        else
+          servers = options.delete(:servers)
+          @connection = ::Dalli::Client.new(servers, options)
+        end
+      end
+
+      def pipeline(&block)
+        yield block
+      end
+
+      def get_all(type)
+        connection.get(type) || {}
+      end
+
+      def get(type, key)
+        connection.get(type).try(key)
+      end
+
+      def set(type, key, val)
+        obj = get_all(type).merge(key => val)
+        connection.set(type, obj)
+      end
+
+      def multiset(type, *args)
+        vals = args.extract_options!
+        obj = get_all(type).merge(vals)
+        connection.set(type, obj)
+      end
+
+      def delete(type, key)
+        obj = get_all(type)
+        obj.delete(key)
+        connection.set(type, obj)
+      end
+
+      def delete_all(type)
+        connection.delete(type)
+      end
+
+      # def expire(key, len)
+      #   connection.expire(key, len)
+      # end
+
+      # def exists(type)
+      #   connection.exists(key)
+      # end
+
+      # def incrby(type, key, incr=1)
+      #   # TODO
+      # end
+    end
+  end
+end

data/lib/slack-bot-manager/manager/storage/redis.rb

@@ -0,0 +1,55 @@
+require 'redis'
+
+module SlackBotManager
+  module Storage
+    class Redis
+      attr_accessor :connection
+
+      def initialize(options)
+        @connection = options.is_a?(Redis) ? options : ::Redis.new(options)
+      end
+
+      def pipeline(&block)
+        connection.pipelined do
+          yield block
+        end
+      end
+
+      def get_all(type)
+        connection.hgetall(type)
+      end
+
+      def get(type, key)
+        connection.get(type, key)
+      end
+
+      def set(type, key, val)
+        connection.hset(type, key, val)
+      end
+
+      def multiset(type, *args)
+        connection.hmset(type, *args)
+      end
+
+      def delete(type, key)
+        connection.hdel(type, key)
+      end
+
+      def delete_all(type)
+        connection.del(type)
+      end
+
+      # def expire(key, len)
+      #   connection.expire(key, len)
+      # end
+
+      # def exists(type)
+      #   connection.exists(key)
+      # end
+
+      # def incrby(type, key, incr=1)
+      #   # TODO
+      # end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module SlackBotManager
+  module Storage
+    autoload :Redis, 'slack-bot-manager/manager/storage/redis'
+    autoload :Dalli, 'slack-bot-manager/manager/storage/dalli'
+  end
+end