connect_client 0.1.0

data/lib/connect_client.rb

@@ -0,0 +1,41 @@
+require_relative 'connect_client/client'
+require_relative 'connect_client/configuration'
+
+module ConnectClient
+  class << self
+
+    def configure
+      config = Configuration.new
+      yield(config)
+
+      @client = ConnectClient::Client.new config
+    end
+
+    def reset
+      @client = nil
+    end
+
+    def method_missing(method, *args, &block)
+      return super unless client.respond_to?(method)
+      client.send(method, *args, &block)
+    end
+
+    def respond_to?(method)
+      return (!@client.nil? && @client.respond_to?(method)) || super
+    end   
+
+    private
+
+    def client
+      raise UnconfiguredError if @client.nil?
+
+      @client
+    end 
+  end
+
+  class UnconfiguredError < StandardError
+    def message
+      "Connect must configured before it can be used, please call Connect.configure"
+    end
+  end
+end

data/lib/connect_client/client.rb

@@ -0,0 +1,43 @@
+require_relative 'http/event_endpoint'
+require_relative 'event'
+
+module ConnectClient
+  class Client
+
+    def initialize(config)
+      @end_point = ConnectClient::Http::EventEndpoint.new config
+    end
+
+    def push(collection_name_or_batches, event_or_events = nil)
+      has_multiple_events = event_or_events.is_a?(Array)
+      has_collection_name = collection_name_or_batches.is_a?(String)
+      is_batch = !has_collection_name || has_multiple_events
+
+      if is_batch
+        batch = create_batch(has_collection_name, collection_name_or_batches, event_or_events)
+        @end_point.push_batch batch
+      else
+        @end_point.push(collection_name_or_batches, ConnectClient::Event.new(event_or_events))
+      end
+    end
+
+    private
+
+    def create_batch(has_collection_name, collection_name_or_batches, event_or_events)
+
+      batches = has_collection_name ?
+                { collection_name_or_batches.to_sym => event_or_events } :
+                collection_name_or_batches
+
+      create_event = Proc.new do |event_data| 
+          ConnectClient::Event.new event_data
+      end
+
+      map_all_events = Proc.new do |col_name, events| 
+        [col_name, events.map(&create_event)]
+      end
+
+      Hash[batches.map(&map_all_events)]
+    end
+  end
+end

data/lib/connect_client/configuration.rb

@@ -0,0 +1,12 @@
+module ConnectClient
+  class Configuration
+  attr_accessor :base_url, :api_key, :project_id, :async
+
+  def initialize(api_key = '', project_id = '', async = false, base_url = 'https://api.getconnect.io')
+    @base_url = base_url
+    @api_key = api_key
+    @project_id = project_id
+    @async = async
+  end
+  end
+end

data/lib/connect_client/event.rb

@@ -0,0 +1,52 @@
+require 'securerandom'
+require 'json'
+require 'time'
+
+module ConnectClient
+  class Event
+
+    @@RESERVED_PROPERTY_REGEX = /tp_.+/i
+
+    attr_reader :data
+
+    def initialize(data)
+      event_data_defaults = { id: SecureRandom.uuid, timestamp: Time.now.utc.iso8601 }
+      @data = event_data_defaults.merge(data)
+
+      if (@data[:timestamp].respond_to? :iso8601)
+        @data[:timestamp] = @data[:timestamp].iso8601
+      end
+
+      validate
+    end
+
+    def validate
+      invalid_properties = @data.keys.grep(@@RESERVED_PROPERTY_REGEX)
+
+      raise EventDataValidationError.new(invalid_properties) if invalid_properties.any?
+    end
+
+    def to_json(options = nil)
+      @data.to_json
+    end
+
+    def to_s
+      "Event Data: #{@data}"
+    end
+  end
+
+  class EventDataValidationError < StandardError
+    attr_reader :invalid_property_names
+
+    def initialize(invalid_property_names)
+      @invalid_property_names = invalid_property_names
+    end
+
+    def message
+      messages = ['The following properties use the reserved prefix tp_:'] + @invalid_property_names.map do |property_name|
+        "->#{property_name}"
+      end
+      messages.join "\n"
+    end
+  end
+end

data/lib/connect_client/event_push_response.rb

@@ -0,0 +1,49 @@
+require 'json'
+
+module ConnectClient
+  class EventPushResponse
+    attr_reader :data
+    attr_reader :http_status_code
+
+    def initialize(code, content_type, response_body, events_pushed)
+      @http_status_code = code.to_s
+
+      if content_type.include? 'application/json'
+        body = response_body
+        body = '{}' if response_body.to_s.empty?
+        parse_body(body, events_pushed)
+      else
+        @data = response_body
+      end
+    end
+
+    def success?
+      @http_status_code.start_with? '2'
+    end
+
+    def to_s
+      %{
+        Status: #{@http_status_code}
+        Successful: #{success?}
+        Data: #{data}
+      }
+    end
+
+    private
+
+    def parse_body(body, events_pushed)
+      @data = JSON.parse(body, :symbolize_names => true)
+
+      if (events_pushed.is_a?(Hash) && @data.is_a?(Hash))
+        @data.merge!(events_pushed) do |collection_name, responses, events|
+          responses.zip(events).map do |response, event|
+            response[:event] = event.data 
+            response
+          end
+        end
+      else
+        @data[:event] = events_pushed.data
+      end
+    end
+  end
+end

data/lib/connect_client/http/event_endpoint.rb

@@ -0,0 +1,137 @@
+require 'json'
+require_relative '../event_push_response'
+
+module ConnectClient
+  module Http
+    class EventEndpoint
+      def initialize(config)
+        headers = {
+          "Content-Type" => "application/json", 
+          "Accept" => "application/json",
+          "Accept-Encoding" => "identity",
+          "X-Api-Key" => config.api_key,
+          "X-Project-Id" => config.project_id
+        }
+
+        if config.async
+          @http = Async.new config.base_url, headers
+        else
+          @http = Sync.new config.base_url, headers
+        end
+
+      end
+
+      def push(collection_name, event)
+        path_uri_part = "/events/#{collection_name}"
+
+        @http.send path_uri_part, event.data.to_json, event
+      end
+
+      def push_batch(events_by_collection)
+        path_uri_part = "/events"
+
+        @http.send path_uri_part, events_by_collection.to_json, events_by_collection
+      end
+    end
+
+    private 
+
+    class Sync
+      def initialize(base_url, headers)
+        require 'uri'
+        require 'net/http'
+        require 'net/https'
+        
+        @headers = headers
+        @connect_uri = URI.parse(base_url)
+        @http = Net::HTTP.new(@connect_uri.host, @connect_uri.port)
+        setup_ssl if @connect_uri.scheme == 'https'
+      end
+
+      def send(path, body, events)
+        response = @http.post(path, body, @headers)
+        ConnectClient::EventPushResponse.new response.code, response['Content-Type'], response.body, events
+      end
+
+      private
+
+      def setup_ssl
+        @http.use_ssl = true
+        @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        @http.verify_depth = 5
+        @http.ca_file = File.expand_path("../../../../data/cacert.pem", __FILE__)        
+      end
+    end
+
+    class Async
+
+      def initialize(base_url, headers)
+        require 'em-http-request'
+
+        @headers = headers
+        @base_url = base_url.chomp('/')
+      end
+
+      def send(path, body, events)
+        raise AsyncHttpError unless defined?(EventMachine) && EventMachine.reactor_running?
+
+        use_syncrony = defined?(EM::Synchrony)
+
+        if use_syncrony
+          send_using_synchrony(path, body, events)
+        else
+          send_using_deferred(path, body, events)
+        end
+      end
+
+      def send_using_deferred(path, body, events)
+        deferred = DeferredHttpResponse.new
+        url_string = "#{@base_url}#{path}".chomp('/')
+        http = EventMachine::HttpRequest.new(url_string).post(:body => body, :head => @headers)
+        http_callback = Proc.new do
+          begin
+            response = create_response http, events
+            deferred.succeed response
+          rescue => error
+            deferred.fail error
+          end
+        end
+
+        http.callback &http_callback
+        http.errback &http_callback
+
+        deferred
+      end
+
+      def send_using_synchrony(path, body, events)
+        url_string = "#{@base_url}#{path}".chomp('/')
+        http = EventMachine::HttpRequest.new(url_string).
+                post(:body => body, :head => @headers)
+
+        create_response http, events
+      end
+
+      def create_response(http_reponse, events)
+        status = http_reponse.response_header.status
+        content_type = http_reponse.response_header['Content-Type']
+        if (http_reponse.error.to_s.empty?)
+          ConnectClient::EventPushResponse.new status, content_type, http_reponse.response, events
+        else
+          ConnectClient::EventPushResponse.new status, content_type, http_reponse.error, events
+        end
+      end
+    end
+
+    class DeferredHttpResponse
+      include EventMachine::Deferrable
+      alias_method :response_received, :callback
+      alias_method :error_occured, :errback
+    end
+
+    class AsyncHttpError < StandardError
+      def message
+        "An EventMachine loop must be running to send an async http request via 'em-http-request'"
+      end
+    end
+  end
+end

data/lib/connect_client/version.rb

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

data/spec/connect_client/client_spec.rb

@@ -0,0 +1,48 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'webmock/minitest'
+require 'connect_client/client'
+require 'connect_client/event_push_response'
+require 'connect_client/configuration'
+require 'securerandom'
+
+describe ConnectClient::Client do
+  before do  
+    @client = ConnectClient::Client.new (ConnectClient::Configuration.new)
+    @async_client = ConnectClient::Client.new (ConnectClient::Configuration.new '', '', true)
+    @sample_event = { id: SecureRandom.uuid, timestamp: Time.now.utc.iso8601, name: 'sample' }
+    @sample_events = [@sample_event]
+    @sample_events_reponse = '{"sample": [{"success": true}]}'
+    @sample_collection = 'sample'
+  end
+
+  it "should get a push response back when pushing a single event to a collection" do
+    stub_request(:post, "https://api.getconnect.io/events/#{@sample_collection}").
+      with(:body => @sample_event).
+      to_return(:status => 200, :body => "", :headers => { 'Content-Type'=>'application/json' })
+
+    response = @client.push @sample_collection, @sample_event
+
+    response.must_be_instance_of ConnectClient::EventPushResponse
+  end
+
+  it "should get a push response back when pushing multiple events to a collection" do
+    stub_request(:post, "https://api.getconnect.io/events").
+      with(:body => { @sample_collection.to_sym => @sample_events }).
+      to_return(:status => 200, :body => @sample_events_reponse, :headers => { 'Content-Type'=>'application/json' })
+
+    response = @client.push @sample_collection, @sample_events
+
+    response.must_be_instance_of ConnectClient::EventPushResponse
+  end
+
+  it "should get a push response back when pushing batches" do
+    batch = { @sample_collection.to_sym => @sample_events }
+    stub_request(:post, "https://api.getconnect.io/events").
+      with(:body => batch).
+      to_return(:status => 200, :body => @sample_events_reponse, :headers => { 'Content-Type'=>'application/json' })
+
+    response = @client.push batch
+    response.must_be_instance_of ConnectClient::EventPushResponse
+  end
+end

data/spec/connect_client/configuration_spec.rb

@@ -0,0 +1,55 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'connect_client/configuration'
+
+describe ConnectClient::Configuration do
+
+  it "should default the base_url to production" do
+    config = ConnectClient::Configuration.new
+
+    config.base_url.must_equal 'https://api.getconnect.io'
+  end
+
+  it "should default async to false" do
+    config = ConnectClient::Configuration.new
+
+    config.async.must_equal false
+  end
+
+  it "should support setting the project id" do
+    config = ConnectClient::Configuration.new
+    id = 'id'
+
+    config.project_id = id
+
+    config.project_id.must_equal id
+  end
+
+  it "should support setting the push key" do
+    config = ConnectClient::Configuration.new
+    key = 'key'
+
+    config.api_key = key
+
+    config.api_key.must_equal key
+  end
+
+  it "should support setting whether requests are async" do
+    config = ConnectClient::Configuration.new
+    async = true
+
+    config.async = async
+
+    config.async.must_equal async
+  end
+
+  it "should support setting the base url" do
+    config = ConnectClient::Configuration.new
+    url = 'url'
+
+    config.base_url = url
+
+    config.base_url.must_equal url
+  end
+
+end