eventflit 0.1.0

data/lib/eventflit/native_notification/client.rb

@@ -0,0 +1,68 @@
+module Eventflit
+  module NativeNotification
+    class Client
+      attr_reader :app_id, :host
+
+      API_PREFIX = "publisher/app/"
+
+      def initialize(app_id, host, scheme, eventflit_client)
+        @app_id = app_id
+        @host = host
+        @scheme = scheme
+        @eventflit_client = eventflit_client
+      end
+
+      # Send a notification via the native notifications API
+      def notify(interests, data = {})
+        Request.new(
+          @eventflit_client,
+          :post,
+          url("/publishes"),
+          {},
+          payload(interests, data)
+        ).send_sync
+      end
+
+      private
+
+      # {
+      #   interests: [Array of interests],
+      #   apns: {
+      #     See https://docs.eventflit.com/push_notifications/ios/server
+      #   },
+      #   gcm: {
+      #     See https://docs.eventflit.com/push_notifications/android/server
+      #   }
+      # }
+      #
+      # @raise [Eventflit::Error] if the interests array is empty
+      # @return [String]
+      def payload(interests, data)
+        interests = Array(interests).map(&:to_s)
+
+        raise Eventflit::Error, "Interests array must not be empty" if interests.length == 0
+
+        data = deep_symbolize_keys!(data)
+
+        data.merge!(interests: interests)
+
+        MultiJson.encode(data)
+      end
+
+      def url(path = nil)
+        URI.parse("#{@scheme}://#{@host}/#{API_PREFIX}/#{@app_id}#{path}")
+      end
+
+      # Symbolize all keys in the hash recursively
+      def deep_symbolize_keys!(hash)
+        hash.keys.each do |k|
+          ks = k.respond_to?(:to_sym) ? k.to_sym : k
+          hash[ks] = hash.delete(k)
+          deep_symbolize_keys!(hash[ks]) if hash[ks].kind_of?(Hash)
+        end
+
+        hash
+      end
+    end
+  end
+end

data/lib/eventflit/request.rb

@@ -0,0 +1,109 @@
+require 'eventflit-signature'
+require 'digest/md5'
+require 'multi_json'
+
+module Eventflit
+  class Request
+    attr_reader :body, :params
+
+    def initialize(client, verb, uri, params, body = nil)
+      @client, @verb, @uri = client, verb, uri
+      @head = {
+        'X-Eventflit-Library' => 'eventflit-http-ruby ' + Eventflit::VERSION
+      }
+
+      @body = body
+      if body
+        params[:body_md5] = Digest::MD5.hexdigest(body)
+        @head['Content-Type'] = 'application/json'
+      end
+
+      request = Eventflit::Signature::Request.new(verb.to_s.upcase, uri.path, params)
+      request.sign(client.authentication_token)
+      @params = request.signed_params
+    end
+
+    def send_sync
+      http = @client.sync_http_client
+
+      begin
+        response = http.request(@verb, @uri, @params, @body, @head)
+      rescue HTTPClient::BadResponseError, HTTPClient::TimeoutError,
+             SocketError, Errno::ECONNREFUSED => e
+        error = Eventflit::HTTPError.new("#{e.message} (#{e.class})")
+        error.original_error = e
+        raise error
+      end
+
+      body = response.body ? response.body.chomp : nil
+
+      return handle_response(response.code.to_i, body)
+    end
+
+    def send_async
+      if defined?(EventMachine) && EventMachine.reactor_running?
+        http_client = @client.em_http_client(@uri)
+        df = EM::DefaultDeferrable.new
+
+        http = case @verb
+        when :post
+          http_client.post({
+            :query => @params, :body => @body, :head => @head
+          })
+        when :get
+          http_client.get({
+            :query => @params, :head => @head
+          })
+        else
+          raise "Unsupported verb"
+        end
+        http.callback {
+          begin
+            df.succeed(handle_response(http.response_header.status, http.response.chomp))
+          rescue => e
+            df.fail(e)
+          end
+        }
+        http.errback { |e|
+          message = "Network error connecting to eventflit (#{http.error})"
+          Eventflit.logger.debug(message)
+          df.fail(Error.new(message))
+        }
+
+        return df
+      else
+        http = @client.sync_http_client
+
+        return http.request_async(@verb, @uri, @params, @body, @head)
+      end
+    end
+
+    private
+
+    def handle_response(status_code, body)
+      case status_code
+      when 200
+        return symbolize_first_level(MultiJson.decode(body))
+      when 202
+        return body.empty? ? true : symbolize_first_level(MultiJson.decode(body))
+      when 400
+        raise Error, "Bad request: #{body}"
+      when 401
+        raise AuthenticationError, body
+      when 404
+        raise Error, "404 Not found (#{@uri.path})"
+      when 407
+        raise Error, "Proxy Authentication Required"
+      else
+        raise Error, "Unknown error (status code #{status_code}): #{body}"
+      end
+    end
+
+    def symbolize_first_level(hash)
+      hash.inject({}) do |result, (key, value)|
+        result[key.to_sym] = value
+        result
+      end
+    end
+  end
+end

data/lib/eventflit/resource.rb

@@ -0,0 +1,36 @@
+module Eventflit
+  class Resource
+    def initialize(client, path)
+      @client = client
+      @path = path
+    end
+
+    def get(params)
+      create_request(:get, params).send_sync
+    end
+
+    def get_async(params)
+      create_request(:get, params).send_async
+    end
+
+    def post(params)
+      body = MultiJson.encode(params)
+      create_request(:post, {}, body).send_sync
+    end
+
+    def post_async(params)
+      body = MultiJson.encode(params)
+      create_request(:post, {}, body).send_async
+    end
+
+    private
+
+    def create_request(verb, params, body = nil)
+      Request.new(@client, verb, url, params, body)
+    end
+
+    def url
+      @_url ||= @client.url(@path)
+    end
+  end
+end

data/lib/eventflit/version.rb

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

data/lib/eventflit/webhook.rb

@@ -0,0 +1,110 @@
+require 'multi_json'
+require 'openssl'
+
+module Eventflit
+  # Used to parse and authenticate WebHooks
+  #
+  # @example Sinatra
+  #   post '/webhooks' do
+  #     webhook = Eventflit::WebHook.new(request)
+  #     if webhook.valid?
+  #       webhook.events.each do |event|
+  #         case event["name"]
+  #         when 'channel_occupied'
+  #           puts "Channel occupied: #{event["channel"]}"
+  #         when 'channel_vacated'
+  #           puts "Channel vacated: #{event["channel"]}"
+  #         end
+  #       end
+  #     else
+  #       status 401
+  #     end
+  #     return
+  #   end
+  #
+  class WebHook
+    attr_reader :key, :signature
+
+    # Provide either a Rack::Request or a Hash containing :key, :signature,
+    # :body, and :content_type (optional)
+    #
+    def initialize(request, client = Eventflit)
+      @client = client
+      # For Rack::Request and ActionDispatch::Request
+      if request.respond_to?(:env) && request.respond_to?(:content_type)
+        @key = request.env['HTTP_X_EVENTFLIT_KEY']
+        @signature = request.env["HTTP_X_EVENTFLIT_SIGNATURE"]
+        @content_type = request.content_type
+
+        request.body.rewind
+        @body = request.body.read
+        request.body.rewind
+      else
+        @key, @signature, @body = request.values_at(:key, :signature, :body)
+        @content_type = request[:content_type] || 'application/json'
+      end
+    end
+
+    # Returns whether the WebHook is valid by checking that the signature
+    # matches the configured key & secret. In the case that the webhook is
+    # invalid, the reason is logged
+    #
+    # @param extra_tokens [Hash] If you have extra tokens for your Eventflit app, you can specify them so that they're used to attempt validation.
+    #
+    def valid?(extra_tokens = nil)
+      extra_tokens = [extra_tokens] if extra_tokens.kind_of?(Hash)
+      if @key == @client.key
+        return check_signature(@client.secret)
+      elsif extra_tokens
+        extra_tokens.each do |token|
+          return check_signature(token[:secret]) if @key == token[:key]
+        end
+      end
+      Eventflit.logger.warn "Received webhook with unknown key: #{key}"
+      return false
+    end
+
+    # Array of events (as Hashes) contained inside the webhook
+    #
+    def events
+      data["events"]
+    end
+
+    # The time at which the WebHook was initially triggered by Eventflit, i.e.
+    # when the event occurred
+    #
+    # @return [Time]
+    #
+    def time
+      Time.at(data["time_ms"].to_f/1000)
+    end
+
+    # Access the parsed WebHook body
+    #
+    def data
+      @data ||= begin
+        case @content_type
+        when 'application/json'
+          MultiJson.decode(@body)
+        else
+          raise "Unknown Content-Type (#{@content_type})"
+        end
+      end
+    end
+
+    private
+
+    # Checks signature against secret and returns boolean
+    #
+    def check_signature(secret)
+      digest = OpenSSL::Digest::SHA256.new
+      expected = OpenSSL::HMAC.hexdigest(digest, secret, @body)
+      if @signature == expected
+        return true
+      else
+        Eventflit.logger.warn "Received WebHook with invalid signature: got #{@signature}, expected #{expected}"
+        return false
+      end
+    end
+  end
+end

data/spec/channel_spec.rb

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Eventflit::Channel do
+  before do
+    @client = Eventflit::Client.new({
+      :app_id => '20',
+      :key => '12345678900000001',
+      :secret => '12345678900000001',
+      :host => 'service.eventflit.com',
+      :port => 80,
+    })
+    @channel = @client['test_channel']
+  end
+
+  let(:eventflit_url_regexp) { %r{/apps/20/events} }
+
+  def stub_post(status, body = nil)
+    options = {:status => status}
+    options.merge!({:body => body}) if body
+
+    stub_request(:post, eventflit_url_regexp).to_return(options)
+  end
+
+  def stub_post_to_raise(e)
+    stub_request(:post, eventflit_url_regexp).to_raise(e)
+  end
+
+  describe '#trigger!' do
+    it "should use @client.trigger internally" do
+      expect(@client).to receive(:trigger)
+      @channel.trigger('new_event', 'Some data')
+    end
+  end
+
+  describe '#trigger' do
+    it "should log failure if error raised in http call" do
+      stub_post_to_raise(HTTPClient::BadResponseError)
+
+      expect(Eventflit.logger).to receive(:error).with("Exception from WebMock (HTTPClient::BadResponseError) (Eventflit::HTTPError)")
+      expect(Eventflit.logger).to receive(:debug) #backtrace
+      channel = Eventflit::Channel.new(@client.url, 'test_channel', @client)
+      channel.trigger('new_event', 'Some data')
+    end
+
+    it "should log failure if Eventflit returns an error response" do
+      stub_post 401, "some signature info"
+      expect(Eventflit.logger).to receive(:error).with("some signature info (Eventflit::AuthenticationError)")
+      expect(Eventflit.logger).to receive(:debug) #backtrace
+      channel = Eventflit::Channel.new(@client.url, 'test_channel', @client)
+      channel.trigger('new_event', 'Some data')
+    end
+  end
+
+  describe "#initialization" do
+    it "should not be too long" do
+      expect { @client['b'*201] }.to raise_error(Eventflit::Error)
+    end
+
+    it "should not use bad characters" do
+      expect { @client['*^!±`/""'] }.to raise_error(Eventflit::Error)
+    end
+  end
+
+  describe "#trigger_async" do
+    it "should use @client.trigger_async internally" do
+      expect(@client).to receive(:trigger_async)
+      @channel.trigger_async('new_event', 'Some data')
+    end
+  end
+
+  describe '#info' do
+    it "should call the Client#channel_info" do
+      expect(@client).to receive(:get)
+                           .with("/channels/mychannel", anything)
+                           .and_return({:occupied => true, :subscription_count => 12})
+      @channel = @client['mychannel']
+      @channel.info
+    end
+
+    it "should assemble the requested attributes into the info option" do
+      expect(@client).to receive(:get)
+                           .with(anything, {:info => "user_count,connection_count"})
+                           .and_return({:occupied => true, :subscription_count => 12, :user_count => 12})
+      @channel = @client['presence-foo']
+      @channel.info(%w{user_count connection_count})
+    end
+  end
+
+  describe '#users' do
+    it "should call the Client#channel_users" do
+      expect(@client).to receive(:get).with("/channels/presence-mychannel/users", {}).and_return({:users => {'id' => '4'}})
+      @channel = @client['presence-mychannel']
+      @channel.users
+    end
+  end
+
+  describe "#authentication_string" do
+    def authentication_string(*data)
+      lambda { @channel.authentication_string(*data) }
+    end
+
+    it "should return an authentication string given a socket id" do
+      auth = @channel.authentication_string('1.1')
+
+      expect(auth).to eq('12345678900000001:02259dff9a2a3f71ea8ab29ac0c0c0ef7996c8f3fd3702be5533f30da7d7fed4')
+    end
+
+    it "should raise error if authentication is invalid" do
+      [nil, ''].each do |invalid|
+        expect(authentication_string(invalid)).to raise_error Eventflit::Error
+      end
+    end
+
+    describe 'with extra string argument' do
+      it 'should be a string or nil' do
+        expect(authentication_string('1.1', 123)).to raise_error Eventflit::Error
+        expect(authentication_string('1.1', {})).to raise_error Eventflit::Error
+
+        expect(authentication_string('1.1', 'boom')).not_to raise_error
+        expect(authentication_string('1.1', nil)).not_to raise_error
+      end
+
+      it "should return an authentication string given a socket id and custom args" do
+        auth = @channel.authentication_string('1.1', 'foobar')
+
+        expect(auth).to eq("12345678900000001:#{hmac(@client.secret, "1.1:test_channel:foobar")}")
+      end
+    end
+  end
+
+  describe '#authenticate' do
+    before :each do
+      @custom_data = {:uid => 123, :info => {:name => 'Foo'}}
+    end
+
+    it 'should return a hash with signature including custom data and data as json string' do
+      allow(MultiJson).to receive(:encode).with(@custom_data).and_return 'a json string'
+
+      response = @channel.authenticate('1.1', @custom_data)
+
+      expect(response).to eq({
+        :auth => "12345678900000001:#{hmac(@client.secret, "1.1:test_channel:a json string")}",
+        :channel_data => 'a json string'
+      })
+    end
+
+    it 'should fail on invalid socket_ids' do
+      expect {
+        @channel.authenticate('1.1:')
+      }.to raise_error Eventflit::Error
+
+      expect {
+        @channel.authenticate('1.1foo', 'channel')
+      }.to raise_error Eventflit::Error
+
+      expect {
+        @channel.authenticate(':1.1')
+      }.to raise_error Eventflit::Error
+
+      expect {
+        @channel.authenticate('foo1.1', 'channel')
+      }.to raise_error Eventflit::Error
+
+      expect {
+        @channel.authenticate('foo', 'channel')
+      }.to raise_error Eventflit::Error
+    end
+  end
+end