iopromise 0.1.1 → 0.1.2

data/lib/iopromise/faraday.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'faraday/connection'
-
-module IOPromise
-  module Faraday
-    class << self
-      def new(url = nil, options = {}, &block)
-        options = ::Faraday.default_connection_options.merge(options)
-        ::IOPromise::Faraday::Connection.new(url, options) do |faraday|
-          faraday.adapter :typhoeus
-          block.call unless block.nil?
-        end
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/connection.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-
-require_relative 'promise'
-
-module IOPromise
-  module Faraday
-    class Connection < ::Faraday::Connection
-      def with_deferred_parallel
-        @parallel_manager = FaradayPromise.parallel_manager
-        yield
-      ensure
-        @parallel_manager = nil
-      end
-      
-      def get_as_promise(*args, **kwargs)
-        @parallel_manager = FaradayPromise.parallel_manager
-        FaradayPromise.new(get(*args, **kwargs))
-      ensure
-        @parallel_manager = nil
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/continuable_hydra.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'typhoeus'
-require_relative 'multi_socket_action'
-
-module IOPromise
-  module Faraday
-    class ContinuableHydra < Typhoeus::Hydra
-      class << self
-        def for_current_thread
-          Thread.current[:faraday_promise_typhoeus_hydra] ||= new
-        end
-      end
-    
-      def initialize(options = {})
-        super(options)
-        
-        @multi = MultiSocketAction.new(options.reject{|k,_| k==:max_concurrency})
-      end
-    
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        # fill up the curl easy handle as much as possible
-        dequeue_many
-    
-        @multi.execute_continue(ready_readers, ready_writers, ready_exceptions)
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/executor_pool.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'continuable_hydra'
-
-module IOPromise
-  module Faraday
-    class FaradayExecutorPool < IOPromise::ExecutorPool::Base
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        # mark all pending promises as executing since they could be started any time now.
-        # ideally we would do this on dequeue.
-        @pending.each do |promise|
-          begin_executing(promise) unless promise.started_executing?
-        end
-
-        ContinuableHydra.for_current_thread.execute_continue(ready_readers, ready_writers, ready_exceptions)
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/multi_socket_action.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'ethon'
-
-Ethon::Curl.ffi_lib 'curl'
-Ethon::Curl.attach_function :multi_socket_action, :curl_multi_socket_action, [:pointer, :int, :int, :pointer], :multi_code
-
-module IOPromise
-  module Faraday
-    class MultiSocketAction < Ethon::Multi
-      CURL_POLL_NONE = 0
-      CURL_POLL_IN = 1
-      CURL_POLL_OUT = 2
-      CURL_POLL_INOUT = 3
-      CURL_POLL_REMOVE = 4
-    
-      CURL_SOCKET_BAD = -1
-      CURL_SOCKET_TIMEOUT = CURL_SOCKET_BAD
-    
-      CURLM_OK = 0
-
-      CURL_CSELECT_IN  = 0x01
-      CURL_CSELECT_OUT = 0x02
-      CURL_CSELECT_ERR = 0x04
-      
-      def initialize(options = {})
-        super(options)
-    
-        @read_fds = {}
-        @write_fds = {}
-        @select_timeout = nil
-    
-        self.socketfunction = @keep_socketfunction = proc do |handle, sock, what, userp, socketp|
-          if what == CURL_POLL_REMOVE
-            @read_fds.delete(sock)
-            @write_fds.delete(sock)
-          else
-            # reuse existing if we have it anywhere
-            io = @read_fds[sock] || @write_fds[sock] || IO.for_fd(sock).tap { |io| io.autoclose = false }
-            if what == CURL_POLL_INOUT
-              @read_fds[sock] = io
-              @write_fds[sock] = io
-            elsif what == CURL_POLL_IN
-              @read_fds[sock] = io
-              @write_fds.delete(sock)
-            elsif what == CURL_POLL_OUT
-              @read_fds.delete(sock)
-              @write_fds[sock] = io
-            end
-          end
-          CURLM_OK
-        end
-    
-        self.timerfunction = @keep_timerfunction = proc do |handle, timeout_ms, userp|
-          if timeout_ms > 0x7fffffffffffffff # FIXME: wrongly encoded
-            @select_timeout = nil
-          else
-            @select_timeout = timeout_ms.to_f / 1_000
-          end
-          CURLM_OK
-        end
-      end
-    
-      def perform
-        # stubbed out, we don't want any of the multi_perform logic
-      end
-    
-      def run
-        # stubbed out, we don't want any of the multi_perform logic
-      end
-    
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        running_handles = ::FFI::MemoryPointer.new(:int)
-        
-        flags = Hash.new(0)
-    
-        unless ready_readers.nil?
-          ready_readers.each do |s|
-            flags[s.fileno] |= CURL_CSELECT_IN
-          end
-        end
-        unless ready_writers.nil?
-          ready_writers.each do |s|
-            flags[s.fileno] |= CURL_CSELECT_OUT
-          end
-        end
-        unless ready_exceptions.nil?
-          ready_exceptions.each do |s|
-            flags[s.fileno] |= CURL_CSELECT_ERR
-          end
-        end
-        
-        flags.each do |fd, bitmask|
-          Ethon::Curl.multi_socket_action(handle, fd, bitmask, running_handles)
-        end
-    
-        if flags.empty?
-          Ethon::Curl.multi_socket_action(handle, CURL_SOCKET_TIMEOUT, 0, running_handles)
-        end
-    
-        check
-    
-        [@read_fds.values, @write_fds.values, [], @select_timeout]
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/promise.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'continuable_hydra'
-require_relative 'executor_pool'
-
-module IOPromise
-  module Faraday
-    class FaradayPromise < ::IOPromise::Base
-      def self.parallel_manager
-        ContinuableHydra.for_current_thread
-      end
-    
-      def initialize(response = nil)
-        super()
-    
-        @response = response
-        @started = false
-
-        unless @response.nil?
-          @response.on_complete do |response_env|
-            fulfill(@response)
-            execute_pool.complete(self)
-          end
-        end
-    
-        ::IOPromise::ExecutorContext.current.register(self) unless @response.nil?
-      end
-    
-      def wait
-        if @response.nil?
-          super
-        else
-          ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
-        end
-      end
-    
-      def execute_pool
-        FaradayExecutorPool.for(Thread.current)
-      end
-    end
-  end
-end

data/lib/iopromise/rack/context_middleware.rb

@@ -1,20 +0,0 @@
-
-module IOPromise
-  module Rack
-    class ContextMiddleware
-      def initialize(app)
-        @app = app
-      end
-    
-      def call(env)
-        ::IOPromise::ExecutorContext.push
-        begin
-          status, headers, body = @app.call(env)
-        ensure
-          ::IOPromise::ExecutorContext.pop
-        end
-        [status, headers, body]
-      end
-    end
-  end
-end