eventflit-client 0.1.0

data/eventflit-client.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eventflit-client/version'
+
+Gem::Specification.new do |s|
+  s.name             = 'eventflit-client'
+  s.version          = EventflitClient::VERSION
+  s.authors          = ["Eventflit", "Logan Koester"]
+  s.email            = ['support@eventflit.com']
+  s.homepage         = 'http://github.com/eventflit/eventflit-websocket-ruby'
+  s.summary          = 'Client for consuming WebSockets from http://eventflit.com'
+  s.description      = 'Client for consuming WebSockets from http://eventflit.com'
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f|
+    File.basename(f)
+  }
+  s.extra_rdoc_files = %w(LICENSE.txt README.md)
+  s.require_paths    = ['lib']
+  s.licenses         = ['MIT']
+
+  s.add_runtime_dependency 'websocket', '~> 1.0'
+  s.add_runtime_dependency 'json'
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "bundler"
+end

data/examples/hello_eventflit.rb

@@ -0,0 +1,19 @@
+# Usage: $ EVENTFLIT_KEY=YOURKEY ruby examples/hello_eventflit.rb
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require 'eventflit-client'
+require 'pp'
+
+APP_KEY = ENV['EVENTFLIT_KEY'] # || "YOUR_APPLICATION_KEY"
+
+socket = EventflitClient::Socket.new(APP_KEY)
+
+# Subscribe to a channel
+socket.subscribe('helloeventflit')
+
+# Bind to a channel event
+socket['helloeventflit'].bind('hello') do |data|
+  pp data
+end
+
+socket.connect

data/examples/hello_eventflit_async.rb

@@ -0,0 +1,22 @@
+# Usage: $ EVENTFLIT_KEY=YOURKEY ruby examples/hello_eventflit_async.rb
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require 'eventflit-client'
+require 'pp'
+
+APP_KEY = ENV['EVENTFLIT_KEY'] # || "YOUR_APPLICATION_KEY"
+
+socket = EventflitClient::Socket.new(APP_KEY)
+socket.connect(true)
+
+# Subscribe to a channel
+socket.subscribe('helloeventflit')
+
+# Bind to a channel event
+socket['helloeventflit'].bind('hello') do |data|
+  pp data
+end
+
+loop do
+  sleep 1
+end

data/examples/hello_eventflit_ssl.rb

@@ -0,0 +1,19 @@
+# Usage: $ EVENTFLIT_KEY=YOURKEY ruby examples/hello_eventflit_ssl.rb
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require 'eventflit-client'
+require 'pp'
+
+APP_KEY = ENV['EVENTFLIT_KEY'] # || "YOUR_APPLICATION_KEY"
+
+socket = EventflitClient::Socket.new(APP_KEY, { :encrypted => true } )
+
+# Subscribe to a channel
+socket.subscribe('helloeventflit')
+
+# Bind to a channel event
+socket['helloeventflit'].bind('hello') do |data|
+  pp data
+end
+
+socket.connect

data/examples/subscribe_private.rb

@@ -0,0 +1,20 @@
+# Usage: $ EVENTFLIT_KEY=YOURKEY ruby examples/subscribe_private.rb
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require 'eventflit-client'
+require 'pp'
+
+APP_KEY = ENV['EVENTFLIT_KEY'] # || "YOUR_APPLICATION_KEY"
+APP_SECRET = ENV['EVENTFLIT_SECRET'] # || "YOUR_APPLICATION_SECRET"
+
+socket = EventflitClient::Socket.new(APP_KEY, { :encrypted => true, :secret => APP_SECRET } )
+
+# Subscribe to a channel
+socket.subscribe('private-helloeventflit')
+
+# Bind to a channel event
+socket['helloeventflit'].bind('hello') do |data|
+  pp data
+end
+
+socket.connect

data/lib/eventflit-client/channel.rb

@@ -0,0 +1,56 @@
+module EventflitClient
+
+  class Channel
+    attr_accessor :global, :subscribed
+    attr_reader :name, :callbacks, :user_data
+
+    def initialize(channel_name, user_data=nil, logger=EventflitClient.logger)
+      @name = channel_name
+      @user_data = user_data
+      @logger = logger
+      @global = false
+      @callbacks = {}
+      @subscribed = false
+    end
+
+    def bind(event_name, &callback)
+      EventflitClient.logger.debug "Binding #{event_name} to #{name}"
+      @callbacks[event_name] = callbacks[event_name] || []
+      @callbacks[event_name] << callback
+      return self
+    end
+
+    def dispatch_with_all(event_name, data)
+      dispatch(event_name, data)
+    end
+
+    def dispatch(event_name, data)
+      logger.debug("Dispatching #{global ? 'global ' : ''}callbacks for #{event_name}")
+      if @callbacks[event_name]
+        @callbacks[event_name].each do |callback|
+          callback.call(data)
+        end
+      else
+        logger.debug "No #{global ? 'global ' : ''}callbacks to dispatch for #{event_name}"
+      end
+    end
+
+    def acknowledge_subscription(data)
+      @subscribed = true
+    end
+
+    private
+
+    attr_reader :logger
+  end
+
+  class NullChannel
+    def initialize(channel_name, *a)
+      @name = channel_name
+    end
+    def method_missing(*a)
+      raise ArgumentError, "Channel `#{@name}` hasn't been subscribed yet."
+    end
+  end
+
+end

data/lib/eventflit-client/channels.rb

@@ -0,0 +1,35 @@
+module EventflitClient
+  class Channels
+
+    attr_reader :channels
+
+    def initialize(logger=EventflitClient.logger)
+      @logger = logger
+      @channels = {}
+    end
+
+    def add(channel_name, user_data=nil)
+      @channels[channel_name] ||= Channel.new(channel_name, user_data, @logger)
+    end
+
+    def find(channel_name)
+      @channels[channel_name]
+    end
+
+    def remove(channel_name)
+      @channels.delete(channel_name)
+    end
+
+    def empty?
+      @channels.empty?
+    end
+
+    def size
+      @channels.size
+    end
+
+    alias :<< :add
+    alias :[] :find
+
+  end
+end

data/lib/eventflit-client/socket.rb

@@ -0,0 +1,244 @@
+require 'json'
+require 'openssl'
+require 'digest/md5'
+
+module EventflitClient
+  class Socket
+
+    CLIENT_ID = 'eventflit-ruby-client'
+    PROTOCOL = '6'
+
+    attr_reader :path, :connected, :channels, :global_channel, :socket_id
+
+    def initialize(app_key, options={})
+      raise ArgumentError, "Missing app_key" if app_key.to_s.empty?
+
+      @path = "#{options[:ws_path]}/app/#{app_key}?client=#{CLIENT_ID}&version=#{EventflitClient::VERSION}&protocol=#{PROTOCOL}"
+      @key = app_key.to_s
+      @secret = options[:secret]
+      @socket_id = nil
+      @logger = options[:logger] || EventflitClient.logger
+      @channels = Channels.new(@logger)
+      @global_channel = Channel.new('eventflit_global_channel')
+      @global_channel.global = true
+      @connected = false
+      @encrypted = options[:encrypted] || options[:secure] || false
+      # :private_auth_method is deprecated
+      @auth_method = options[:auth_method] || options[:private_auth_method]
+      @cert_file = options[:cert_file]
+      @ws_host = options[:ws_host] || HOST
+      @ws_port = options[:ws_port] || WS_PORT
+      @wss_port = options[:wss_port] || WSS_PORT
+      @ssl_verify = options.fetch(:ssl_verify, true)
+
+      if @encrypted
+        @url = "wss://#{@ws_host}:#{@wss_port}#{@path}"
+      else
+        @url = "ws://#{@ws_host}:#{@ws_port}#{@path}"
+      end
+
+      bind('eventflit:connection_established') do |data|
+        socket = parser(data)
+        @connected = true
+        @socket_id = socket['socket_id']
+        subscribe_all
+      end
+
+      bind('eventflit:connection_disconnected') do |data|
+        @connected = false
+        @channels.channels.each { |c| c.disconnect }
+      end
+
+      bind('eventflit:error') do |data|
+        logger.fatal("Eventflit : error : #{data.inspect}")
+      end
+
+      # Keep this in case we're using a websocket protocol that doesn't
+      # implement ping/pong
+      bind('eventflit:ping') do
+        send_event('eventflit:pong', nil)
+      end
+    end
+
+    def connect(async = false)
+      return if @connection
+      logger.debug("Eventflit : connecting : #{@url}")
+
+      if async
+        @connection_thread = Thread.new do
+          begin
+            connect_internal
+          rescue => ex
+            send_local_event "eventflit:error", ex
+          end
+        end
+      else
+        connect_internal
+      end
+      self
+    end
+
+    def disconnect
+      return unless @connection
+      logger.debug("Eventflit : disconnecting")
+      @connected = false
+      @connection.close
+      @connection = nil
+      if @connection_thread
+        @connection_thread.kill
+        @connection_thread = nil
+      end
+    end
+
+    def subscribe(channel_name, user_data = nil)
+      if user_data.is_a? Hash
+        user_data = user_data.to_json
+      elsif user_data
+        user_data = {:user_id => user_data}.to_json
+      elsif is_presence_channel(channel_name)
+        raise ArgumentError, "user_data is required for presence channels"
+      end
+
+      channel = @channels.add(channel_name, user_data)
+      if @connected
+        authorize(channel, method(:authorize_callback))
+      end
+      return channel
+    end
+
+    def unsubscribe(channel_name)
+      channel = @channels.remove channel_name
+      if channel && @connected
+        send_event('eventflit:unsubscribe', {
+          'channel' => channel_name
+        })
+      end
+      return channel
+    end
+
+    def bind(event_name, &callback)
+      @global_channel.bind(event_name, &callback)
+      return self
+    end
+
+    def [](channel_name)
+      @channels[channel_name] || NullChannel.new(channel_name)
+    end
+
+    def subscribe_all
+      @channels.channels.clone.each { |k,v| subscribe(v.name, v.user_data) }
+    end
+
+    # auth for private and presence
+    def authorize(channel, callback)
+      if is_private_channel(channel.name)
+        auth_data = get_private_auth(channel)
+      elsif is_presence_channel(channel.name)
+        auth_data = get_presence_auth(channel)
+      end
+      # could both be nil if didn't require auth
+      callback.call(channel, auth_data, channel.user_data)
+    end
+
+    def authorize_callback(channel, auth_data, channel_data)
+      send_event('eventflit:subscribe', {
+        'channel' => channel.name,
+        'auth' => auth_data,
+        'channel_data' => channel_data
+      })
+      channel.acknowledge_subscription(nil)
+    end
+
+    def is_private_channel(channel_name)
+      channel_name.match(/^private-/)
+    end
+
+    def is_presence_channel(channel_name)
+      channel_name.match(/^presence-/)
+    end
+
+    def get_private_auth(channel)
+      return @auth_method.call(@socket_id, channel) if @auth_method
+
+      string_to_sign = @socket_id + ':' + channel.name
+      signature = hmac(@secret, string_to_sign)
+      "#{@key}:#{signature}"
+    end
+
+    def get_presence_auth(channel)
+      return @auth_method.call(@socket_id, channel) if @auth_method
+
+      string_to_sign = @socket_id + ':' + channel.name + ':' + channel.user_data
+      signature = hmac(@secret, string_to_sign)
+      "#{@key}:#{signature}"
+    end
+
+
+    # for compatibility with JavaScript client API
+    alias :subscribeAll :subscribe_all
+
+    def send_event(event_name, data)
+      payload = {'event' => event_name, 'data' => data}.to_json
+      @connection.send(payload)
+      logger.debug("Eventflit : sending event : #{payload}")
+    end
+
+    def send_channel_event(channel, event_name, data)
+      payload = {'channel' => channel, 'event' => event_name, 'data' => data}.to_json
+      @connection.send(payload)
+      logger.debug("Eventflit : sending channel event : #{payload}")
+    end
+
+  protected
+
+    attr_reader :logger
+
+    def connect_internal
+      @connection = EventflitWebSocket.new(@url, {
+        :ssl => @encrypted,
+        :cert_file => @cert_file,
+        :ssl_verify => @ssl_verify
+      })
+
+      logger.debug("Websocket connected")
+
+      loop do
+        @connection.receive.each do |msg|
+          params = parser(msg)
+
+          # why ?
+          next if params['socket_id'] && params['socket_id'] == self.socket_id
+
+          send_local_event(params['event'], params['data'], params['channel'])
+        end
+      end
+    end
+
+    def send_local_event(event_name, event_data, channel_name=nil)
+      if channel_name
+        channel = @channels[channel_name]
+        if channel
+          channel.dispatch_with_all(event_name, event_data)
+        end
+      end
+
+      @global_channel.dispatch_with_all(event_name, event_data)
+      logger.debug("Eventflit : event received : channel: #{channel_name}; event: #{event_name}")
+    end
+
+    def parser(data)
+      return data if data.is_a? Hash
+      return JSON.parse(data)
+    rescue => err
+      logger.warn(err)
+      logger.warn("Eventflit : data attribute not valid JSON - you may wish to implement your own Eventflit::Client.parser")
+      return data
+    end
+
+    def hmac(secret, string_to_sign)
+      digest = OpenSSL::Digest::SHA256.new
+      signature = OpenSSL::HMAC.hexdigest(digest, secret, string_to_sign)
+    end
+  end
+
+end

data/lib/eventflit-client/version.rb

@@ -0,0 +1,3 @@
+module EventflitClient
+  VERSION = "0.1.0"
+end

data/lib/eventflit-client/websocket.rb

@@ -0,0 +1,99 @@
+require 'socket'
+require 'websocket'
+require 'openssl'
+
+module EventflitClient
+  class EventflitWebSocket
+    WAIT_EXCEPTIONS  = [Errno::EAGAIN, Errno::EWOULDBLOCK]
+    WAIT_EXCEPTIONS << IO::WaitReadable if defined?(IO::WaitReadable)
+
+    CA_FILE = File.expand_path('../../../certs/cacert.pem', __FILE__)
+
+    attr_accessor :socket
+
+    def initialize(url, params = {})
+      @hs ||= WebSocket::Handshake::Client.new(:url => url)
+      @frame ||= WebSocket::Frame::Incoming::Server.new(:version => @hs.version)
+      @socket = TCPSocket.new(@hs.host, @hs.port || 80)
+      @cert_file = params[:cert_file]
+      @logger = params[:logger] || EventflitClient.logger
+
+      if params[:ssl] == true
+        ctx = OpenSSL::SSL::SSLContext.new
+        if params[:ssl_verify]
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+          # http://curl.haxx.se/ca/cacert.pem
+          ctx.ca_file = @cert_file || CA_FILE
+        else
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        ssl_sock = OpenSSL::SSL::SSLSocket.new(@socket, ctx)
+        ssl_sock.sync_close = true
+        ssl_sock.connect
+
+        @socket = ssl_sock
+      end
+
+      @socket.write(@hs.to_s)
+      @socket.flush
+
+      loop do
+        data = @socket.getc
+        next if data.nil?
+
+        @hs << data
+
+        if @hs.finished?
+          raise @hs.error.to_s unless @hs.valid?
+          @handshaked = true
+          break
+        end
+      end
+    end
+
+    def send(data, type = :text)
+      raise "no handshake!" unless @handshaked
+
+      data = WebSocket::Frame::Outgoing::Client.new(
+        :version => @hs.version,
+        :data => data,
+        :type => type
+      ).to_s
+      @socket.write data
+      @socket.flush
+    end
+
+    def receive
+      raise "no handshake!" unless @handshaked
+
+      begin
+        data = @socket.read_nonblock(1024)
+      rescue *WAIT_EXCEPTIONS
+        IO.select([@socket])
+        retry
+      end
+      @frame << data
+
+      messages = []
+      while message = @frame.next
+        if message.type === :ping
+          send(message.data, :pong)
+          return messages
+        end
+        messages << message.to_s
+      end
+      messages
+    end
+
+    def close
+      @socket.close
+    rescue IOError => error
+      logger.debug error.message
+    end
+
+    private
+
+    attr_reader :logger
+  end
+end

data/lib/eventflit-client.rb

@@ -0,0 +1,22 @@
+module EventflitClient
+  HOST = 'service.eventflit.com'
+  WS_PORT = 80
+  WSS_PORT = 443
+
+  def self.logger
+    @logger ||= begin
+      require 'logger'
+      Logger.new(STDOUT)
+    end
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end
+
+require 'eventflit-client/version'
+require 'eventflit-client/websocket'
+require 'eventflit-client/socket'
+require 'eventflit-client/channel'
+require 'eventflit-client/channels'