rest-core 2.1.2 → 3.0.0

data/example/multi.rb

@@ -1,44 +0,0 @@
-
-require 'fiber'
-require 'em-http-request'
-require 'rest-core'
-
-YourClient = RC::Builder.client do
-  use RC::DefaultSite , 'https://api.github.com/users/'
-  use RC::JsonResponse, true
-  use RC::CommonLogger, method(:puts)
-  use RC::Cache       , nil, 3600
-end
-
-client = YourClient.new
-puts "rest-client with threads doing concurrent requests"
-a = [client.get('cardinalblue'), client.get('godfat')]
-puts "It's not blocking... but doing concurrent requests underneath"
-p a.map{ |r| r['name'] } # here we want the values, so it blocks here
-puts "DONE"
-
-puts; puts
-
-puts "eventmachine with threads doing concurrent requests"
-EM.run{
-  Thread.new{
-    a = [client.get('cardinalblue'), client.get('godfat')]
-    p a.map{ |r| r['name'] } # here we want the values, so it blocks here
-    puts "DONE"
-    EM.stop
-  }
-  puts "It's not blocking... but doing concurrent requests underneath"
-}
-
-puts; puts
-
-puts "eventmachine with fibers doing concurrent requests"
-EM.run{
-  Fiber.new{
-    a = [client.get('cardinalblue'), client.get('godfat')]
-    p a.map{ |r| r['name'] } # here we want the values, so it blocks here
-    puts "DONE"
-    EM.stop
-  }.resume
-  puts "It's not blocking... but doing concurrent requests underneath"
-}

data/lib/rest-core/engine/auto.rb

@@ -1,25 +0,0 @@
-
-require 'rest-core/middleware'
-
-class RestCore::Auto
-  include RestCore::Middleware
-  def call env, &k
-    client = http_client
-    client.call(log(env, "Auto   picked: #{client.class}"), &k)
-  end
-
-  def http_client
-    if         Object.const_defined?(:EventMachine) &&
-       ::EventMachine.const_defined?(:HttpRequest)  &&
-       ::EventMachine.reactor_running?              &&
-       # it should be either wrapped around a thread or a fiber
-       ((Thread.main != Thread.current) ||
-        (Fiber.respond_to?(:current) && RootFiber != Fiber.current))
-
-      @emhttprequest ||= RestCore::EmHttpRequest.new
-
-    else
-      @restclient    ||= RestCore::RestClient.new
-    end
-  end
-end

data/lib/rest-core/engine/em-http-request.rb

@@ -1,90 +0,0 @@
-
-require 'em-http-request'
-require 'restclient/payload'
-
-require 'rest-core/engine/future/future'
-require 'rest-core/middleware'
-
-class RestCore::EmHttpRequest
-  include RestCore::Middleware
-  def call env, &k
-    future = Future.create(env, k, env[ASYNC])
-
-    # eventmachine is not thread-safe, so...
-    # https://github.com/igrigorik/em-http-request/issues/190#issuecomment-16995528
-    ::EventMachine.schedule{ request(future, env) }
-
-    env.merge(RESPONSE_BODY    => future.proxy_body,
-              RESPONSE_STATUS  => future.proxy_status,
-              RESPONSE_HEADERS => future.proxy_headers,
-              FUTURE           => future)
-  end
-
-  def request future, env
-    payload, headers = Payload.generate_with_headers(env[REQUEST_PAYLOAD],
-                                                     env[REQUEST_HEADERS])
-    args = if payload.nil?
-             {}
-           else
-             tmpfile = payload2file(payload)
-             if tmpfile.respond_to?(:path)
-               {:file => tmpfile.path}
-             else
-               {:body => tmpfile}
-             end
-           end.merge(:head => headers)
-
-    client  = ::EventMachine::HttpRequest.new(request_uri(env)).
-                send(env[REQUEST_METHOD], args)
-
-    client.callback{
-      close_tmpfile(tmpfile)
-      future.on_load(client.response,
-                     client.response_header.status,
-                     client.response_header)}
-
-    client.errback{
-      close_client(client)
-      close_tmpfile(tmpfile)
-      future.on_error(client.error)}
-
-    env[TIMER].on_timeout{
-      close_client(client)
-      close_tmpfile(tmpfile)
-      future.on_error(env[TIMER].error)
-    } if env[TIMER]
-  end
-
-  def payload2file payload
-    if payload.io.respond_to?(:path) # already a file
-      payload.io
-
-    elsif payload.size == 0 ||       # probably a socket, buffer to disc
-          payload.size >= 81920      # probably too large, buffer to disc
-      create_tmpfile(payload.io)
-
-    else                             # probably not worth buffering to disc
-      payload.read
-    end
-  end
-
-  def create_tmpfile io
-    tempfile = Tempfile.new("rest-core.em-http-request.#{rand(1_000_000)}")
-    IO.copy_stream(io, tempfile)
-    tempfile
-  end
-
-  def close_client client
-    (client.instance_variable_get(:@callbacks)||[]).clear
-    (client.instance_variable_get(:@errbacks )||[]).clear
-    client.close
-  end
-
-  def close_tmpfile tmpfile
-    if tmpfile.respond_to?(:close!)   # tempfile
-      tmpfile.close!
-    elsif tmpfile.respond_to?(:close) # regular IO
-      tmpfile.close
-    end
-  end
-end

data/lib/rest-core/engine/future/future.rb

@@ -1,107 +0,0 @@
-
-require 'rest-core'
-
-class RestCore::Future
-  include RestCore
-
-  class Proxy < BasicObject
-    def initialize future, target
-      @future, @target = future, target
-    end
-
-    def method_missing msg, *args, &block
-      @future.yield[@target].__send__(msg, *args, &block)
-    end
-  end
-
-  def self.create *args, &block
-    if Fiber.respond_to?(:current) && RootFiber != Fiber.current &&
-       # because under a thread, Fiber.current won't return the root fiber
-       Thread.main == Thread.current
-      FutureFiber .new(*args, &block)
-    else
-      FutureThread.new(*args, &block)
-    end
-  end
-
-  def initialize env, k, immediate
-    self.env       = env
-    self.k         = k
-    self.immediate = immediate
-    self.response, self.body, self.status, self.headers, self.error = nil
-  end
-
-  def proxy_body   ; Proxy.new(self, RESPONSE_BODY   ); end
-  def proxy_status ; Proxy.new(self, RESPONSE_STATUS ); end
-  def proxy_headers; Proxy.new(self, RESPONSE_HEADERS); end
-
-  def wrap  ; raise NotImplementedError; end
-  def wait  ; raise NotImplementedError; end
-  def resume; raise NotImplementedError; end
-
-  def loaded?
-    !!status
-  end
-
-  def yield
-    wait
-    callback
-  end
-
-  def callback
-    self.response ||= k.call(
-      env.merge(RESPONSE_BODY    => body  ,
-                RESPONSE_STATUS  => status,
-                RESPONSE_HEADERS => headers,
-                FAIL             => ((env[FAIL]||[]) + [error]).compact,
-                LOG              =>  (env[LOG] ||[]) +
-                                      ["Future picked: #{self.class}"]))
-  end
-
-  def callback_in_async
-    callback
-  rescue Exception => e
-    # nothing we can do here for an asynchronous exception,
-    # so we just log the error
-    logger = method(:warn) # TODO: add error_log_method
-    logger.call "RestCore: ERROR: #{e}\n  from #{e.backtrace.inspect}"
-  end
-
-  def on_load body, status, headers
-    env[TIMER].cancel if env[TIMER]
-    synchronize{
-      self.body, self.status, self.headers = body, status, headers
-    }
-    # under ASYNC callback, should call immediately
-    next_tick{ callback_in_async } if immediate
-    resume # client or response might be waiting
-  end
-
-  def on_error error
-    self.error = if error.kind_of?(Exception)
-                   error
-                 else
-                   Error.new(error || 'unknown')
-                 end
-    on_load('', 0, {})
-  end
-
-  protected
-  attr_accessor :env, :k, :immediate,
-                :response, :body, :status, :headers, :error
-
-  private
-  def synchronize; yield; end
-  # next_tick is used for telling the reactor that there's something else
-  # should be done, don't sleep and don't stop at the moment
-  def next_tick
-    if Object.const_defined?(:EventMachine) && EventMachine.reactor_running?
-      EventMachine.next_tick{ yield }
-    else
-      yield
-    end
-  end
-
-  autoload :FutureFiber , 'rest-core/engine/future/future_fiber'
-  autoload :FutureThread, 'rest-core/engine/future/future_thread'
-end

data/lib/rest-core/engine/future/future_fiber.rb

@@ -1,32 +0,0 @@
-
-require 'fiber'
-
-class RestCore::Future::FutureFiber < RestCore::Future
-  def initialize *args
-    super
-    self.fibers = []
-  end
-
-  def wrap
-    Fiber.new{ yield }.resume
-  end
-
-  def wait
-    fibers << Fiber.current
-    Fiber.yield until loaded? # it might be resumed by some other futures!
-  end
-
-  def resume
-    return if fibers.empty?
-    current_fibers = fibers.dup
-    fibers.clear
-    current_fibers.each{ |f|
-      next unless f.alive?
-      next_tick{ f.resume }
-    }
-    resume
-  end
-
-  protected
-  attr_accessor :fibers
-end

data/lib/rest-core/engine/future/future_thread.rb

@@ -1,29 +0,0 @@
-
-require 'thread'
-
-class RestCore::Future::FutureThread < RestCore::Future
-  def initialize *args
-    super
-    self.condv = ConditionVariable.new
-    self.mutex = Mutex.new
-  end
-
-  def wrap
-    Thread.new{ yield }
-  end
-
-  def wait
-    # it might be awaken by some other futures!
-    synchronize{ condv.wait(mutex) until loaded? } unless loaded?
-  end
-
-  def resume
-    condv.broadcast
-  end
-
-  protected
-  attr_accessor :condv, :mutex
-
-  private
-  def synchronize; mutex.synchronize{ yield }; end
-end

data/lib/rest-core/middleware/timeout/timer_em.rb

@@ -1,26 +0,0 @@
-
-require 'eventmachine'
-
-class RestCore::Timeout::TimerEm < ::EventMachine::Timer
-  attr_accessor :timeout, :error
-
-  def initialize timeout, error, &block
-    super(timeout, &block) if block_given?
-    self.timeout = timeout
-    self.error   = error
-    @canceled    = false
-  end
-
-  def on_timeout &block
-    send(:initialize, timeout, error, &block)
-  end
-
-  def cancel
-    super
-    @canceled = true
-  end
-
-  def canceled?
-    @canceled
-  end
-end

data/lib/rest-core/middleware/timeout/timer_thread.rb

@@ -1,36 +0,0 @@
-
-class RestCore::Timeout::TimerThread
-  attr_accessor :timeout, :error
-
-  def initialize timeout, error, &block
-    t = Thread.current
-    self.timeout = timeout
-    self.error   = error
-    self.block   = block || lambda{ t.raise error }
-    @canceled    = false
-    start
-  end
-
-  def on_timeout &block
-    self.block = block
-  end
-
-  def cancel
-    @canceled = true
-  end
-
-  def canceled?
-    @canceled
-  end
-
-  def start
-    return if timeout.nil? || timeout.zero?
-    self.thread = Thread.new{
-      sleep(timeout)
-      block.call unless canceled?
-    }
-  end
-
-  protected
-  attr_accessor :block, :thread
-end

data/task/.gitignore

@@ -1 +0,0 @@
-*.rbc

data/test/test_em-http-request.rb

@@ -1,186 +0,0 @@
-
-require 'rest-core/test'
-
-describe RC::EmHttpRequest do
-  should 'raise RC::Error' do
-    EM.run{Fiber.new{
-      lambda{
-        RC::Universal.new.get('http://localhost:1').tap{}
-      }.should.raise(RC::Error)
-      EM.stop
-    }.resume}
-  end
-
-  should 'never crash EM!' do
-    EM.error_handler{ |e| e.should.kind_of?(NoMethodError); EM.stop}
-    EM.run{Fiber.new{
-      RC::Simple.new.get('http://localhost:1').no_such_method
-    }.resume}
-  end
-
-  describe 'POST Payload' do
-    after do
-      WebMock.reset!
-    end
-
-    client = RC::Builder.client
-    client.builder.run(RC::EmHttpRequest)
-    path = 'http://example.com'
-    ok   = 'OK'
-    c    = client.new
-
-    post = lambda do |payload, body|
-      stub_request(:post, path).with(:body => body).to_return(:body => ok)
-      EM.error_handler{ |e| e.should.kind_of?(NilClass); EM.stop }
-      EM.run{ EM.defer{
-        c.post(path, payload).should.eq ok
-        EM.next_tick{ EM.stop }
-      }}
-    end
-
-    should 'post with string' do
-      post['string', 'string']
-    end
-
-    should 'post with file' do
-      File.open(__FILE__) do |f|
-        b = f.read
-        f.rewind
-        post[f, b]
-      end
-    end
-
-    should 'post with socket' do
-      rd, wr = IO.pipe
-      wr.write('socket')
-      wr.close
-      post[rd, 'socket']
-    end
-  end
-
-  # ----------------------------------------------------------------------
-
-  describe RC::Simple do
-    before do
-      @path = 'http://example.com'
-      stub_request(:get, @path).to_return(:body => 'OK')
-    end
-
-    should 'work with EM' do
-      EM.run{Fiber.new{
-        RC::Simple.new.get(@path).should.eq 'OK'; EM.stop}.resume}
-    end
-  end
-
-  # ----------------------------------------------------------------------
-
-  describe RC::Timeout do
-    after do
-      WebMock.reset!
-      RR.verify
-    end
-
-    should 'cancel timeout for fiber' do
-      any_instance_of(RC::Timeout::TimerEm) do |timer|
-        proxy.mock(timer).cancel.times(2)
-      end
-      path = 'http://example.com/'
-      stub_request(:get, path).to_return(:body => 'response')
-      c = RC::Builder.client do
-        use RC::Timeout, 10
-        use RC::Cache, {}, 3600
-        run RC::EmHttpRequest
-      end.new
-      EM.run{ Fiber.new{
-        c.request(RC::REQUEST_PATH => path).should.eq 'response'
-        c.request(RC::REQUEST_PATH => path).should.eq 'response'
-        EM.stop }.resume }
-      c.cache.size.should.eq 1
-    end
-
-    should 'cancel timeout for async' do
-      path = 'http://example.com/'
-      any_instance_of(RC::Timeout::TimerEm) do |timer|
-        mock(timer).cancel.times(2)
-      end
-      stub_request(:get, path).to_return(:body => 'response')
-      c = RC::Builder.client do
-        use RC::Timeout, 10
-        use RC::Cache, {}, 3600
-        run RC::EmHttpRequest
-      end.new
-      EM.run{
-        c.request_full(RC::REQUEST_PATH => path){
-          c.request_full(RC::REQUEST_PATH => path){
-            EM.stop }}}
-      c.cache.size.should.eq 1
-    end
-
-    should 'return correct result for futures' do
-      path = 'http://example.com/'
-      stub_request(:get, path).to_return(:body => 'response')
-
-      c = RC::Builder.client do
-        use RC::Timeout, 10
-        run RC::EmHttpRequest
-      end.new
-      EM.run{Fiber.new{c.get(path).should.eq('response');EM.stop}.resume}
-    end
-
-    describe 'raise exception' do
-      should 'default timeout' do
-        c = RC::Builder.client do
-          use RC::Timeout, 0.00001
-          run Class.new{
-            def call env
-              sleep 1
-              yield(env)
-            end
-          }
-        end.new
-        lambda{ c.get('') }.should.raise ::Timeout::Error
-      end
-
-      should 'future timeout' do
-        port = 35795
-        path = "http://localhost:#{port}/"
-
-        c = RC::Builder.client do
-          use RC::Timeout, 0.00001
-          run RC::EmHttpRequest
-        end.new
-
-        EM.run{
-          EM.start_server '127.0.0.1', port, Module.new{
-            def receive_data data; end
-          }
-          Fiber.new{
-            begin
-              c.get(path).tap{}
-            rescue => e
-              e.should.kind_of ::Timeout::Error
-              EM.stop
-            end
-          }.resume}
-      end
-
-      should 'async timeout' do
-        port = 35795
-        path = "http://localhost:#{port}/"
-
-        c = RC::Builder.client do
-          use RC::Timeout, 0.00001
-          use RC::ErrorHandler
-          run RC::EmHttpRequest
-        end.new
-
-        EM.run{
-          EM.start_server '127.0.0.1', port, Module.new{
-            def receive_data data; end
-          }
-          c.get(path){ |e| e.should.kind_of ::Timeout::Error; EM.stop }
-        }
-      end
-    end
-  end
-end unless RUBY_ENGINE == 'jruby'