slack-rtm-receiver 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1821e8e1626538c67c4d4decf64cd3535011a2af
+  data.tar.gz: ab3b8e9761278e7988ecc4455d798f1522fa22c9
+SHA512:
+  metadata.gz: 49680d9a6a7fd5221a7f5d5f904c0c401c65b719c018de616742cbff52dc6899e2a573f7b31bedbff5653e85d12d685aa68b5d6dc8ef59ca2a2b2c96ae0c27eb
+  data.tar.gz: c4c5d3750d586452ef925e7cd0abaf5edb75934d8c8c2aaa57a441db00caaad2a1d2b2712e688ced049167f4e2a4746fa4aae901752a27b563c636e99441d7f3

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Ken J.
+
+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,60 @@
+# slack-rtm-receiver
+
+A Ruby gem. It connects to Slack Real Time Messaging API to receive events. Runs on EventMachine.
+
+## Requirements
+
+- Ruby 2.0.0 <=
+- eventmachine 1.0
+- em-http-request 1.1
+- faye-websocket 0.8
+
+## Getting Started
+
+### Install
+
+```
+$ gem install slack-rtm-receiver
+```
+
+### Use
+
+```
+require 'slack-rtm-receiver'
+```
+
+Create an object to respond to received events. You can subclass **EventHandler**.
+```
+class MyHandler < SlackRTMReceiver::EventHandler
+  def process_event(event, session)
+    if event[:text] == 'hi'
+      res_event = {
+        type: 'message',
+        channel: event[:channel],
+        text: 'Hi!'
+      }
+      session.send_event(res_event)
+    end
+  end
+end
+SlackRTMReceiver.add_event_handler(MyHandler.new)
+```
+Or, you can pass a block. The following works the same as above.
+```
+SlackRTMReceiver::EventHandler.add_type('message') do |event, session|
+  if event[:text] == 'hi'
+    res_event = {
+      type: 'message',
+      channel: event[:channel],
+      text: 'Hi!'
+    }
+    session.send_event(res_event)
+  end
+end
+```
+
+Start the reactor to connect to Slack.
+```
+opts = {token: 'xoxb-1234abcd5678efgh'}
+SlackRTMReceiver::Reactor.run(opts)
+```

data/lib/slack-rtm-receiver.rb

@@ -0,0 +1,11 @@
+require 'slack-rtm-receiver/event-handler'
+require 'slack-rtm-receiver/logger'
+require 'slack-rtm-receiver/reactor'
+require 'slack-rtm-receiver/session'
+require 'slack-rtm-receiver/starter'
+require 'slack-rtm-receiver/version'
+
+
+module SlackRTMReceiver
+
+end

data/lib/slack-rtm-receiver/event-handler.rb

@@ -0,0 +1,48 @@
+module SlackRTMReceiver
+
+  def self.event_handlers=(handlers)
+    @event_handlers = handlers
+  end
+
+  def self.event_handlers
+    @event_handlers ||= []
+  end
+
+  def self.add_event_handler(handler)
+    @event_handlers ||= []
+    @event_handlers << handler
+  end
+
+  # Create objects to handle events:
+  #  - subclass EventHandler, or
+  #  - just create an instance and pass a block
+  class EventHandler
+
+    # Create and register a handler object by passing a block
+    # @param type [String] event type
+    def self.add_type(type, &block)
+      handler = new(type, &block)
+      SlackRTMReceiver.add_event_handler(handler)
+    end
+
+    attr_reader :type
+
+    # Create a new handler instance
+    # @param type [String] event type
+    def initialize(type = 'message', &block)
+      @type = type
+      @block = block if block_given?
+    end
+
+    # Callback method; called by SlackRTMReceiver::Session when event is received
+    # @param [Hash] event data
+    # @param [Object] caller object
+    def process_event(event, session)
+      logger = session.logger
+      logger.debug "#{self.class.name} running..."
+      @block.call(event, session) if @block
+    end
+
+  end
+
+end

data/lib/slack-rtm-receiver/logger.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+
+module SlackRTMReceiver
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger ||= NullLogger.new()
+  end
+
+  class NullLogger < Logger
+
+    def initialize(*args)
+    end
+
+    def add(*args, &block)
+    end
+
+  end
+
+end

data/lib/slack-rtm-receiver/reactor.rb

@@ -0,0 +1,32 @@
+require 'eventmachine'
+
+
+module SlackRTMReceiver
+
+  class Reactor
+
+    # Start reactor
+    # @param opts [Hash] options for Slack web API rtm.start
+    def self.run(opts)
+      logger = SlackRTMReceiver.logger
+      logger.info "SlackRTMReceiver ver. #{Version} loaded, Reactor starting..."
+      EM.run do
+        session = Session.new
+        starter = Starter.start(session, opts)
+
+        # life check
+        EM.add_periodic_timer(15) do
+          session.alive? ? session.ping_if_idle : starter.start(session)
+        end
+
+        # statistics check
+        EM.add_periodic_timer(3600) do
+          session.stats({log: true}) if session.alive?
+        end
+      end
+      logger.warn 'Reactor stopped'
+    end
+
+  end
+
+end

data/lib/slack-rtm-receiver/session.rb

@@ -0,0 +1,199 @@
+require 'faye/websocket'
+
+
+module SlackRTMReceiver
+
+  # Websocket client for the RTM session
+  class Session
+
+    attr_reader :logger
+    attr_reader :websocket
+    alias_method :ws, :websocket
+    attr_reader :last_timestamp
+    alias_method :ts, :last_timestamp
+
+    def initialize
+      @logger = SlackRTMReceiver.logger
+      logger.debug 'Initializing Session...'
+      @websocket = nil
+      @last_timestamp = nil
+      @ping = nil
+      @stats = {}
+    end
+
+    # Start RTM websocket session
+    # @param url [String] websocket URL
+    # @return [Boolean] false if a session is already up
+    def start(url)
+      return false if ws
+      logger.debug "Connecting to websocket...\n URL: #{url}"
+      opts = {ping: 60}
+      @websocket = Faye::WebSocket::Client.new(url, nil, opts)
+
+      ws.on :open do
+        logger.debug 'Websocket opened'
+        touch_ts
+      end
+
+      ws.on :message do |ws_event|
+        touch_ts
+        event = JSON.parse(ws_event.data, {symbolize_names: true})
+        case event[:type]
+        when 'hello'
+          hello_handler(event)
+        when 'pong'
+          pong_handler(event)
+        else
+          run_event_handlers(event)
+        end
+        @stats[:events_received] ||= 0
+        @stats[:events_received] += 1
+      end
+
+      ws.on :close do |ws_event|
+        logger.warn 'RTM session closed'
+        cleanup
+      end
+      
+      return true
+    end
+
+    # Send RTM event
+    # @param event [Hash] RTM event; 'id' will be added automatically
+    # @return [Hash] the event that was sent
+    def send_event(event)
+      return nil unless ws
+      event[:id] = new_event_id
+      ws.send(JSON.fast_generate(event))
+      logger.info "Event sent with id: #{event[:id]} type: #{event[:type]}"
+      logger.debug "Sent event: #{event}"
+      return event
+    end
+
+    # True if RTM session is alive
+    def alive?
+      # return true if ws && ts && Time.now - ts < 30
+      return true if ws && ts
+      return false
+    end
+
+    # Idle for how long?
+    # @return [Float] seconds
+    def idle_time
+      return 0 unless alive?
+      return Time.now - ts
+    end
+
+    # Send RTM ping
+    # @param timeout [Fixnum] timeout in seconds
+    # @return [Boolean] true if pinged
+    def ping(timeout = 5)
+      if @ping
+        logger.debug 'RTM ping requested, but another was recently sent. Ignoring...'
+        return false
+      end
+      event = send_event({type: 'ping', time: Time.now.to_f})
+      return false unless event
+      timer = EM::Timer.new(timeout) do
+        logger.warn "RTM ping timed out: threshold #{timeout} sec"
+        close
+      end
+      event[:em_timer] = timer
+      @ping = event
+      @stats[:pings_sent] ||= 0
+      @stats[:pings_sent] += 1
+      return true
+    end
+
+    # Ping if idle for more than set seconds
+    # @param sec [Fixnum] idle time in seconds
+    # @return [Boolean] true if pinged
+    def ping_if_idle(sec = 10)
+      return false if idle_time < sec
+      ping
+    end
+
+    # Return statistics
+    # @param opts [Hash]
+    # @return [Hash]
+    def stats(opts = {})
+      return nil if @stats.empty?
+      secs = Time.now - @stats[:hello_time]
+      secs = secs.to_i
+      days = secs / 86400
+      secs = secs % 86400
+      hours = secs / 3600
+      secs = secs % 3600
+      mins = secs / 60
+      secs = secs % 60
+      if opts[:log]
+        msg = "Statistics since #{@stats[:hello_time]} (#{days} days, #{hours} hrs, #{mins} mins, #{secs} secs)\n"
+        msg << "#{@stats}"
+        logger.info msg
+      end
+      return @stats
+    end
+
+    # Close RTM session
+    def close
+      ws.close if ws
+    end
+
+    private
+
+    # Handle RTM hello
+    def hello_handler(event)
+      @stats[:hello_time] = Time.now
+      logger.info 'Hello received, RTM session established'
+    end
+
+    # Handle RTM pong
+    def pong_handler(event)
+      @stats[:pongs_received] ||= 0
+      @stats[:pongs_received] += 1
+      if @ping.nil? || @ping[:id] != event[:reply_to]
+        logger.warn "Unexpected RTM pong received\n Pong: #{event}"
+        return
+      end
+      latency = Time.now.to_f - @ping[:time]
+      logger.info "RTM pong received, ping latency: #{'%.5f' % latency} sec"
+      @ping[:em_timer].cancel
+      @ping = nil
+      @stats[:last_ping_latency] =  latency
+    end
+
+    # Run matching handlers
+    def run_event_handlers(event)
+      logger.debug "Received event: #{event}"
+      return unless event[:type]
+      handlers = SlackRTMReceiver.event_handlers
+      handlers.each do |handler|
+        handler.process_event(event, self) if handler.type == event[:type]
+      end
+    end
+
+    # Get new RTM event ID
+    def new_event_id
+      @stats[:events_sent] ||= 0
+      return @stats[:events_sent] += 1
+    end
+
+    # Update last timestamp
+    def touch_ts
+      @last_timestamp = Time.now
+    end
+
+    # Reset instance variables
+    def cleanup
+      @hellotime = 0
+      @websocket = nil
+      @last_timestamp = nil
+      @ping = nil
+      stats({log: true})
+      @stats = {}
+      logger.warn 'RTM session closed'
+    end
+
+  end
+
+end

data/lib/slack-rtm-receiver/starter.rb

@@ -0,0 +1,76 @@
+require 'em-http'
+require 'json'
+
+
+module SlackRTMReceiver
+
+  # HTTP client to call rtm.start
+  class Starter
+
+    # Create and start a Starter
+    # @param session [SlackRTMReceiver::Session]
+    # @return [SlackRTMReceiver::Starter]
+    def self.start(session, opts = {})
+      starter = self.new(opts)
+      starter.start(session)
+      return starter
+    end
+
+    attr_reader :logger
+    attr_accessor :options
+
+    # @return [Boolean]
+    def started?
+      return true if @is_starting
+      return true if @session && @session.alive?
+      return false
+    end
+
+    # @param opts [Hash] options for Slack web API rtm.start
+    def initialize(opts)
+      @logger = SlackRTMReceiver.logger
+      logger.debug 'Initializing Starter...'
+      @options = opts
+      @is_starting = false
+      @session = nil
+    end
+
+    # @param session [SlackRTMReceiver::Session]
+    def start(session)
+      if started?
+        logger.debug 'Start requested but already running. Ignoring...'
+        return nil
+      end
+      @is_starting = true
+      @session = session
+      logger.debug 'Starter is calling rtm.start...'
+      baseurl = 'https://slack.com/api/rtm.start'
+      http = EM::HttpRequest.new(baseurl).get(query: @options, redirects: 5)
+      http.callback do
+        callback(http, session)
+        @is_starting = false
+      end
+      http.errback do
+        errback(http)
+        @is_starting = false
+      end
+    end
+
+    private
+
+    # EM::HttpRequest callback handler
+    def callback(http, session)
+      status = http.response_header.status
+      raise "Web API rtm.start failed: received HTTP status code #{status}" unless status == 200
+      logger.info 'Recived rtm.start response'
+      session.start(JSON.parse(http.response)['url'])
+    end
+
+    # EM::HttpRequest error callback handler
+    def errback(http)
+      raise "Web API rtm.start failed: #{http.error}"
+    end
+
+  end
+
+end

data/lib/slack-rtm-receiver/version.rb

@@ -0,0 +1,5 @@
+module SlackRTMReceiver
+
+  Version = '0.0.1'
+
+end

data/slack-rtm-receiver.gemspec

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+require 'slack-rtm-receiver/version'
+
+
+Gem::Specification.new do |s|
+  s.name          = 'slack-rtm-receiver'
+  s.version       = SlackRTMReceiver::Version
+  s.authors       = ['Ken J.']
+  s.email         = ['kenjij@gmail.com']
+  s.description   = %q{Slack RTM receiver}
+  s.summary       = %q{Connects to Slack Real Time Messaging API to receive events.}
+  s.homepage      = 'https://github.com/kenjij/slack-rtm-receiver'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "eventmachine", "~> 1.0"
+  s.add_runtime_dependency "faye-websocket", "~> 0.8"
+  s.add_runtime_dependency "em-http-request", "~> 1.1"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: slack-rtm-receiver
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ken J.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Slack RTM receiver
+email:
+- kenjij@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/slack-rtm-receiver.rb
+- lib/slack-rtm-receiver/event-handler.rb
+- lib/slack-rtm-receiver/logger.rb
+- lib/slack-rtm-receiver/reactor.rb
+- lib/slack-rtm-receiver/session.rb
+- lib/slack-rtm-receiver/starter.rb
+- lib/slack-rtm-receiver/version.rb
+- slack-rtm-receiver.gemspec
+homepage: https://github.com/kenjij/slack-rtm-receiver
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Connects to Slack Real Time Messaging API to receive events.
+test_files: []