client_for_poslynx 0.9.0 → 1.0.0.pre

data/lib/client_for_poslynx/net/em_connector/callback_map.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+
+module ClientForPoslynx
+  module Net
+    class EM_Connector
+
+      def self.CallbackMap(*args)
+        if args.length == 1 && EMC::CallbackMap === args.first
+          return args.first
+        else
+          EMC::CallbackMap.new( *args )
+        end
+      end
+
+      class CallbackMap
+        def initialize(callable_map={})
+          @callable_map = callable_map
+        end
+
+        def ==(other)
+          callable_map == other.callable_map
+        end
+
+        def [](callback_key)
+          callable_map[callback_key]
+        end
+
+        def to_hash
+          callable_map.dup
+        end
+
+        def merge(other)
+          self.class.new(
+            callable_map.merge( other.to_hash )
+          )
+        end
+
+        def call(callback_key, *args)
+          callback = callable_map[callback_key]
+          callback.call *args if callback
+        end
+
+        protected
+
+        attr_reader :callable_map
+      end
+
+    end
+  end
+end

data/lib/client_for_poslynx/net/em_connector/connection_handler.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+module ClientForPoslynx
+  module Net
+    class EM_Connector
+
+      class ConnectionHandler < EM::Connection
+        include EM::Protocols::POSLynx
+        include EMC::HandlesConnection
+      end
+
+    end
+  end
+end

data/lib/client_for_poslynx/net/em_connector/connector_state.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+module ClientForPoslynx
+  module Net
+    class EM_Connector
+
+      class State < Struct.new( :encryption, :connection, :connection_status, :status_of_request )
+
+        def connection_initial? ; connection_status == :initial       ; end
+        def connecting?         ; connection_status == :connecting    ; end
+        def connected?          ; connection_status == :connected     ; end
+        def disconnecting?      ; connection_status == :disconnecting ; end
+        def disconnecting?      ; connection_status == :disconnected  ; end
+
+        def request_initial?  ; status_of_request == :initial      ; end
+        def request_pending?  ; status_of_request == :pending      ; end
+        def got_response?     ; status_of_request == :got_response ; end
+        def request_failed?   ; status_of_request == :failed       ; end
+
+      end
+
+    end
+  end
+end

data/lib/client_for_poslynx/net/em_connector/event_dispatcher.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+
+module ClientForPoslynx
+  module Net
+    class EM_Connector
+
+      class EventDispatcher
+        NULL_LISTENER = ->(*) { }
+
+        class << self
+          private :new
+
+          def null(connection)
+            new( connection )
+          end
+
+          def for_connect(connection, opts)
+            original_dispatcher = opts[:original_dispatcher]
+            callback_map = EMC.CallbackMap(
+              connection_completed: opts[:on_success],
+              unbind:               opts[:on_failure],
+            )
+            new( connection, original_dispatcher, callback_map )
+          end
+
+          def for_disconnect(connection, opts)
+            callback_map = EMC.CallbackMap(
+              unbind: opts[:on_completed]
+            )
+            new( connection, nil, callback_map )
+          end
+
+          def for_send_request(connection, opts)
+            callback_map = EMC.CallbackMap(
+              receive_response: opts[:on_response],
+              unbind:           opts[:on_failure],
+            )
+            new( connection, nil, callback_map )
+          end
+        end
+
+        def initialize(connection, original_dispatcher = nil, callback_map = EMC.CallbackMap())
+          @connection = connection
+          @original_dispatcher = original_dispatcher
+          @callback_map = callback_map
+        end
+
+        def []=(event_type, callback)
+          callback_map[event_type] = callback
+        end
+
+        def event_occurred(event_type, *args)
+          connection.reset_event_dispatcher
+          original_dispatcher.event_occurred( event_type, *args ) if original_dispatcher
+          callback_map.call event_type, *args
+        end
+
+        private
+
+        attr_reader :connection, :original_dispatcher, :callback_map
+
+      end
+
+    end
+  end
+end

data/lib/client_for_poslynx/net/em_connector/handles_connection.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+module ClientForPoslynx
+  module Net
+    class EM_Connector
+
+      module HandlesConnection
+        def initialize(connector_state)
+          @connector_state = connector_state
+          connector_state.connection = self
+          connector_state.connection_status = :connecting
+        end
+
+        attr_writer :event_dispatcher
+
+        def event_dispatcher
+          @event_dispatcher ||= EMC::EventDispatcher.null( self )
+        end
+
+        def reset_event_dispatcher
+          self.event_dispatcher = nil
+        end
+
+        def connection_completed
+          if connector_state.encryption == :use_ssl
+            start_tls
+          else
+            connector_state.connection_status = :connected
+            event_dispatcher.event_occurred :connection_completed
+          end
+        end
+
+        def ssl_handshake_completed
+          connector_state.connection_status = :connected
+          event_dispatcher.event_occurred :connection_completed
+        end
+
+        def unbind
+          connector_state.connection_status = :disconnected
+          connector_state.status_of_request = :failed if connector_state.request_pending?
+          event_dispatcher.event_occurred :unbind
+        end
+
+        def receive_response(response_data)
+          connector_state.status_of_request = :got_response if connector_state.request_pending?
+          event_dispatcher.event_occurred :receive_response, response_data
+        end
+
+        private
+
+        attr_reader :connector_state
+
+      end
+
+    end
+  end
+end

data/lib/client_for_poslynx/net/em_connector/request_call.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+module ClientForPoslynx
+  module Net
+    class EM_Connector
+
+      def self.RequestCall(*args)
+        if args.length == 1 && self::RequestCall === args.first
+          args.first
+        elsif args.first.nil?
+          RequestCall.new(nil, {})
+        else
+          RequestCall.new( *args )
+        end
+      end
+
+      class RequestCall < Struct.new(:request_data, :result_callbacks)
+        def initialize(request_data, result_callbacks={})
+          result_callbacks = EMC.CallbackMap( result_callbacks )
+          super request_data, result_callbacks
+          freeze
+        end
+      end
+
+    end
+  end
+end

data/lib/client_for_poslynx/net/em_protocol.rb

@@ -2,7 +2,7 @@
 
 require 'eventmachine'
 
-module EventMachine
+module EM
   module Protocols
 
     # Sends requests to and receives responses from a Precidia

data/lib/client_for_poslynx/net/em_session.rb

@@ -0,0 +1,250 @@
+# coding: utf-8
+
+module ClientForPoslynx
+  module Net
+
+    # Provides a synchronous, structured API for making
+    # requests to POSLynx host using Event Machine and returning
+    # responses when received.
+    #
+    # Eliminates the need for complicated and messy event
+    # callback chains in POSLynx client code.
+    #
+    # Multiple sessions may be in effect at the same time,
+    # interacting with the same POSLyx host by using the same
+    # Event Machine connector.  This is important for performing
+    # actions such as initiating a new payment interaction when
+    # a previous interaction was abandoned.
+    class EM_Session
+
+      # Base class for errors raised by the session to code that
+      # is running in the context of a sesssion.
+      class Error < StandardError ; end
+
+      # Raised when an error condition is detected while making
+      # a request or while waiting for the response.
+      class RequestError < Error ; end
+
+      # Raised when attempting to make a request while another
+      # session is waiting for a response to a request of the
+      # same type (other than PinPadReset).
+      class ConflictingRequestError < Error ; end
+
+      # Executes the given block in the context of a session
+      # attached to the given Event Machine connector.  The
+      # session is passed as the argument to the block.
+      def self.execute(connector)
+        new( connector ).execute { |s| yield s }
+      end
+
+      attr_reader :connector
+
+      attr_reader :status
+
+      attr_reader :em_system
+
+      # Builds a new EM_Session instance attached to the given
+      # Event Machine connector.
+      #
+      # ==== Options
+      # * <tt>:em_system</tt> - The event machine system that
+      #   will be called on for operations such as adding timers
+      #   and deferring actions.
+      def initialize(connector, opts={})
+        self.connector = connector
+        @em_system = opts.fetch( :em_system, ::EM )
+        self.status = :initialized
+      end
+
+      # Executes the given block in the context of the session
+      # The session is passed as the argument to the block.
+      def execute
+        @fiber = Fiber.new do
+          yield self
+          :done
+        end
+        self.status = :engaged
+        dispatch fiber.resume
+      end
+
+      # Called from within an executed block of code for the
+      # session to send request data to the POSLynx and return
+      # the response to the request once it is received.
+      # If a connection could not be established or is lost
+      # before a response can be received, then a
+      # <tt>RequestError</tt> exception will be raised.
+      #
+      # If another session attempts to supplant this request, but
+      # the response to this request is subsequently received,
+      # then the response is returned as normal, but this
+      # session's status is changed to detached, and any
+      # subsequent request attempts made in this session will
+      # result in <tt>RequestError</tt> being raised.
+      #
+      # If another session is already waiting for a response,
+      # then this will attempt to usurp or supplant the other
+      # request.  If the new request is of the same type as the
+      # existing request, and the type is not PinPadReset, then
+      # this call will raise a <tt>ConflictingRequestError</tt>
+      # exception.
+      def request(data)
+        if status == :detached
+          raise RequestError, "Session cannot make requests because it is detached"
+        end
+        if connector.request_pending?
+          pending_request_data = connector.latest_request.request_data
+          pending_callbacks = connector.latest_request.result_callbacks
+          if Data::Requests::PinPadReset === data && Data::Requests::PinPadReset === pending_request_data
+            pending_callbacks.call :on_failure
+            was_successful, resp_data_or_ex = Fiber.yield( [:_get_response] )
+          elsif data.class == pending_request_data.class
+            raise ConflictingRequestError, "Attempted a request while another request of the same type is in progress"
+          else
+            was_successful, resp_data_or_ex = Fiber.yield( [:_request, data, connector.latest_request] )
+          end
+        else
+          was_successful, resp_data_or_ex = Fiber.yield( [:_request, data] )
+        end
+        raise resp_data_or_ex unless was_successful
+        resp_data_or_ex
+      end
+
+      # Given a block argument, returns control to EventMachine,
+      # executes the block in a separate thread, waits for the
+      # thread to complete, and then returns the value returned
+      # by the block.
+      #
+      # This is implemented behind the scenes using
+      # EventMachine::defer and has the same considerations and
+      # caveats.
+      #
+      # Note that methods of the session should not be called by
+      # code within the block since those methods should only be
+      # called from code running in the main event loop thread.
+      def exec_dissociated(&block)
+        was_successful, resp_data_or_ex = Fiber.yield( [:_exec_dissociated, block] )
+        raise resp_data_or_ex unless was_successful
+        resp_data_or_ex
+      end
+
+      # Returns control to EventMachine, and returns control to
+      # the session code after the given delay-time in seconds.
+      def sleep(delay_time)
+        Fiber.yield [:_sleep, delay_time]
+      end
+
+      private
+
+      attr_writer :connector, :status
+      attr_reader :fiber
+
+      def dispatch(fiber_callback)
+        return if fiber_callback == :done
+        send *fiber_callback
+      end
+
+      def _request(data, overlaps_request=nil)
+        connector.connect(
+          on_success: ->() {
+            send_request_callbacks = response_handlers( overlaps_request )
+            connector.send_request data, send_request_callbacks
+          },
+          on_failure: ->() {
+            dispatch fiber.resume( [false, RequestError.new] )
+          }
+        )
+      rescue => ex
+        dispatch fiber.resume( [false, ex] )
+      end
+
+      def _get_response
+        connector.get_response response_handlers
+      end
+
+      def response_handlers(overlaps_request=nil)
+        overlapped_request_data = overlaps_request && overlaps_request.request_data
+        overlapped_request_callbacks = overlaps_request && overlaps_request.result_callbacks
+        {
+          on_response: on_response_handler( overlaps_request ),
+          on_failure: on_failure_handler( overlaps_request ),
+          on_detached: ->(){ detach! },
+        }
+      end
+
+      def on_response_handler(overlaps_request)
+        overlaps_request ?
+          on_response_handler_with_overlap( overlaps_request ) :
+          simple_on_response_handler
+      end
+
+      def on_response_handler_with_overlap(overlaps_request)
+        overlapped_request_data = overlaps_request && overlaps_request.request_data
+        overlapped_request_callbacks = overlaps_request && overlaps_request.result_callbacks
+        ->(response_data) {
+          if overlapped_request_data.potential_response?( response_data )
+            overlapped_request_callbacks.call :on_detached
+            overlapped_request_callbacks.call :on_response, response_data
+            _get_response
+          else
+            overlapped_request_callbacks.call :on_failure
+            dispatch fiber.resume( [true, response_data] )
+          end
+        }
+      end
+
+      def simple_on_response_handler
+        ->(response_data) {
+          dispatch fiber.resume( [true, response_data] )
+        }
+      end
+
+      def on_failure_handler(overlaps_request)
+        overlaps_request ?
+          on_failure_handler_with_overlap( overlaps_request ) :
+          simple_on_failure_handler
+      end
+
+      def on_failure_handler_with_overlap(overlaps_request)
+        overlapped_request_callbacks = overlaps_request && overlaps_request.result_callbacks
+        ->() {
+          overlapped_request_callbacks.call :on_failure if overlaps_request
+          dispatch fiber.resume( [false, RequestError.new] )
+        }
+      end
+
+      def simple_on_failure_handler
+        ->() {
+          dispatch fiber.resume( [false, RequestError.new] )
+        }
+      end
+
+      def detach!
+        self.connector = nil
+        self.status = :detached
+      end
+
+      def _exec_dissociated op
+        wrapped_op = ->() {
+          begin
+            result = op.call
+            [true, result]
+          rescue => ex
+            [false, ex]
+          end
+        }
+        callback = ->(result) do
+          dispatch fiber.resume result
+        end
+        em_system.defer wrapped_op, callback
+      end
+
+      def _sleep(delay_time)
+        callback = ->() {
+          dispatch fiber.resume
+        }
+        em_system.add_timer delay_time, callback
+      end
+    end
+
+  end
+end