rest-core 3.6.0 → 4.0.0

data/lib/rest-core/thread_pool.rb

@@ -1,131 +0,0 @@
-
-# reference implementation: puma
-# https://github.com/puma/puma/blob/v2.7.1/lib/puma/thread_pool.rb
-
-require 'thread'
-require 'rest-core'
-
-class RestCore::ThreadPool
-  include RestCore
-
-  class Queue
-    def initialize
-      @queue = []
-      @condv = ConditionVariable.new
-    end
-
-    def size
-      @queue.size
-    end
-
-    def << task
-      queue << task
-      condv.signal
-    end
-
-    def pop mutex, timeout=60
-      if queue.empty?
-        condv.wait(mutex, timeout)
-        queue.shift || lambda{ |_| false } # shutdown idle workers
-      else
-        queue.shift
-      end
-    end
-
-    def clear
-      queue.clear
-    end
-
-    protected
-    attr_reader :queue, :condv
-  end
-
-  class Task < Struct.new(:job, :mutex, :thread, :cancelled)
-    # this should never fail
-    def call working_thread
-      mutex.synchronize do
-        return if cancelled
-        self.thread = working_thread
-      end
-      job.call
-      true
-    end
-
-    def cancel
-      self.cancelled = true
-    end
-  end
-
-  def self.[] client_class
-    (@pools ||= {})[client_class] ||= new(client_class)
-  end
-
-  attr_reader :client_class, :workers
-
-  def initialize client_class
-    @client_class = client_class
-    @queue        = Queue.new
-    @mutex        = Mutex.new
-    @workers      = []
-    @waiting      = 0
-  end
-
-  def inspect
-    "#<#{self.class.name} client_class=#{client_class}>"
-  end
-
-  def size
-    workers.size
-  end
-
-  def max_size
-    client_class.pool_size
-  end
-
-  def idle_time
-    client_class.pool_idle_time
-  end
-
-  def defer promise_mutex, &job
-    mutex.synchronize do
-      task = Task.new(job, promise_mutex)
-      queue << task
-      spawn_worker if waiting < queue.size && workers.size < max_size
-      task
-    end
-  end
-
-  def trim force=false
-    mutex.synchronize do
-      queue << lambda{ |_| false } if force || waiting > 0
-    end
-  end
-
-  # Block on shutting down, and should not add more jobs while shutting down
-  def shutdown
-    workers.size.times{ trim(true) }
-    workers.first.join && trim(true) until workers.empty?
-    mutex.synchronize{ queue.clear }
-  end
-
-  protected
-  attr_reader :queue, :mutex, :condv, :waiting
-
-  private
-  def spawn_worker
-    workers << Thread.new{
-      Thread.current.abort_on_exception = true
-
-      task = nil
-      begin
-        mutex.synchronize do
-          @waiting += 1
-          task = queue.pop(mutex, idle_time)
-          @waiting -= 1
-        end
-      end while task.call(Thread.current)
-
-      mutex.synchronize{ workers.delete(Thread.current) }
-    }
-  end
-end

data/lib/rest-core/timer.rb

@@ -1,58 +0,0 @@
-
-require 'thread'
-require 'timers'
-
-class RestCore::Timer
-  @mutex = Mutex.new
-  @interval = 1
-
-  singleton_class.module_eval do
-    attr_accessor :interval
-
-    def group
-      @group ||= @mutex.synchronize{ @group ||= group_new }
-    end
-
-    private
-    def group_new
-      g = Timers::Group.new
-      g.every(interval){}
-      @thread = Thread.new do
-        begin
-          g.wait
-        rescue => e
-          warn "RestCore::Timer: ERROR: #{e}\n  from #{e.backtrace.inspect}"
-        end while g.count > 1
-        @group = nil
-      end
-      g
-    end
-  end
-
-  attr_accessor :timeout, :error, :timer
-  def initialize timeout, error, &block
-    self.timeout = timeout
-    self.error   = error
-    self.block   = block
-    start if block_given?
-  end
-
-  def on_timeout &block
-    self.block = block
-    start if block_given?
-  end
-
-  # should never raise!
-  def cancel
-    timer.cancel if timer
-    self.block = nil
-  end
-
-  def start
-    return if timeout.nil? || timeout.zero?
-    self.timer = self.class.group.after(timeout){ block.call if block }
-  end
-
-  protected
-  attr_accessor :block
-end

data/lib/rest-core/util/payload.rb

@@ -1,173 +0,0 @@
-
-# stolen and modified from rest-client
-
-require 'rest-core/error'
-
-begin
-  require 'mime/types/columnar'
-rescue LoadError
-  require 'mime/types'
-end
-
-require 'stringio'
-require 'tempfile'
-
-module RestCore; end
-class RestCore::Payload
-  include RestCore
-
-  def self.generate_with_headers payload, headers
-    h = if p = generate(payload)
-          p.headers.merge(headers)
-        else
-          headers
-        end
-    [p, h]
-  end
-
-  def self.generate payload
-    if payload.respond_to?(:read)
-      Streamed.new(payload)
-
-    elsif payload.kind_of?(String)
-      StreamedString.new(payload)
-
-    elsif payload.kind_of?(Hash)
-      if payload.empty?
-        nil
-
-      elsif Middleware.contain_binary?(payload)
-        Multipart.new(payload)
-
-      else
-        UrlEncoded.new(payload)
-      end
-
-    else
-      raise Error.new("Payload should be either String, Hash, or" \
-                      " responding to `read', but: #{payload.inspect}")
-    end
-  end
-
-  # Payload API
-  attr_reader  :io
-  alias_method :to_io, :io
-
-  def initialize payload; @io = payload          ; end
-  def read     bytes=nil; io.read(bytes)         ; end
-  def close             ; io.close unless closed?; end
-  def closed?           ; io.closed?             ; end
-  def headers           ; {}                     ; end
-
-  def size
-    if io.respond_to?(:size)
-      io.size
-    elsif io.respond_to?(:stat)
-      io.stat.size
-    else
-      0
-    end
-  end
-
-  class Streamed < Payload
-    def headers
-      {'Content-Length' => size.to_s}
-    end
-  end
-
-  class StreamedString < Streamed
-    def initialize payload
-      super(StringIO.new(payload))
-    end
-  end
-
-  class UrlEncoded < StreamedString
-    def initialize payload
-      super(RestCore::Middleware.percent_encode(payload))
-    end
-
-    def headers
-      super.merge('Content-Type' => 'application/x-www-form-urlencoded')
-    end
-  end
-
-  class Multipart < Streamed
-    EOL = "\r\n"
-
-    def initialize payload
-      super(Tempfile.new("rest-core.payload.#{boundary}"))
-
-      io.binmode
-
-      payload.each_with_index do |(k, v), i|
-        if v.kind_of?(Array)
-          v.each{ |vv| part(k, vv) }
-        else
-          part(k, v)
-        end
-      end
-      io.write("--#{boundary}--#{EOL}")
-      io.rewind
-    end
-
-    def part k, v
-      io.write("--#{boundary}#{EOL}Content-Disposition: form-data")
-      io.write("; name=\"#{k}\"") if k
-      if v.respond_to?(:read)
-        part_binary(k, v)
-      else
-        part_plantext(k, v)
-      end
-    end
-
-    def part_plantext k, v
-      io.write("#{EOL}#{EOL}#{v}#{EOL}")
-    end
-
-    def part_binary k, v
-      if v.respond_to?(:original_filename)                   # Rails
-        io.write("; filename=\"#{v.original_filename}\"#{EOL}")
-      elsif v.respond_to?(:path)                             # files
-        io.write("; filename=\"#{File.basename(v.path)}\"#{EOL}")
-      else                                                   # io
-        io.write("; filename=\"#{k}\"#{EOL}")
-      end
-
-      # supply your own content type for regular files, will you?
-      if v.respond_to?(:content_type)                        # Rails
-        io.write("Content-Type: #{v.content_type}#{EOL}#{EOL}")
-      elsif v.respond_to?(:path) && type = mime_type(v.path) # files
-        io.write("Content-Type: #{type}#{EOL}#{EOL}")
-      else
-        io.write(EOL)
-      end
-
-      while data = v.read(8192)
-        io.write(data)
-      end
-
-      io.write(EOL)
-
-    ensure
-      v.close if v.respond_to?(:close)
-    end
-
-    def mime_type path
-      mime = MIME::Types.type_for(path)
-      mime.first && mime.first.content_type
-    end
-
-    def boundary
-      @boundary ||= rand(1_000_000).to_s
-    end
-
-    def headers
-      super.merge('Content-Type' =>
-                    "multipart/form-data; boundary=#{boundary}")
-    end
-
-    def close
-      io.close! unless io.closed?
-    end
-  end
-end

data/test/test_builder.rb

@@ -1,40 +0,0 @@
-
-require 'rest-core/test'
-
-describe RC::Builder do
-  would 'default client app is a kind of RestCore::Engine' do
-    RC::Builder.client.new.app.should.kind_of? RC::Engine
-  end
-
-  would 'default        app is a kind of RestCore::Engine' do
-    RC::Builder.new.to_app.should.kind_of? RC::Engine
-  end
-
-  would 'switch default_engine to RestCore::Dry a' do
-    builder = Class.new(RC::Builder)
-    builder.default_engine = RC::Dry
-    builder.new.to_app.class.should.eq RC::Dry
-  end
-
-  would 'switch default_engine to RestCore::Dry b' do
-    builder = RC::Builder.dup
-    builder.default_engine = RC::Dry
-    builder.client.new.app.class.should.eq RC::Dry
-  end
-
-  would 'accept middleware without a member' do
-    RC::Builder.client{
-      use Class.new.send(:include, RC::Middleware)
-    }.members.should.eq [:config_engine]
-  end
-
-  would 'not have duplicated fields' do
-    middleware = Class.new do
-      def self.members; [:value]; end
-      include RC::Middleware
-    end
-    client = RC::Builder.client(:value){ use middleware }.new
-    client.value = 10
-    client.value.should.eq 10
-  end
-end

data/test/test_client.rb

@@ -1,177 +0,0 @@
-
-require 'rest-core/test'
-
-describe RC::Simple do
-  after do
-    WebMock.reset!
-    Muack.verify
-  end
-
-  url = 'http://example.com/'
-
-  would 'do simple request' do
-    c = RC::Simple.new
-    [:get, :post, :delete, :put, :patch].each do |method|
-      stub_request(method, url).to_return(:body => '[]')
-      c.send(method, url).should.eq '[]'
-    end
-
-    stub_request(:head   , url).to_return(:headers => {'A' => 'B'})
-    c.   head(url).should.eq('A' => 'B')
-
-    stub_request(:options, url).to_return(:headers => {'A' => 'B'})
-    c.options(url).should.eq('A' => 'B')
-  end
-
-  would 'call the callback' do
-    [:get, :post, :delete, :put, :patch].each do |method|
-      stub_request(method, url).to_return(:body => '123')
-      (client = RC::Simple.new).send(method, url){ |res|
-        res.should.eq '123' }.should.eq client
-      client.wait
-    end
-
-    stub_request(:head, url).to_return(:headers => {'A' => 'B'})
-    (client = RC::Simple.new).head(url){ |res|
-      res.should.eq({'A' => 'B'})
-    }.should.eq client
-    client.wait
-
-    stub_request(:options, url).to_return(:headers => {'A' => 'B'})
-    (client = RC::Simple.new).options(url){ |res|
-      res.should.eq('A' => 'B')
-    }.should.eq client
-    client.wait
-  end
-
-  would 'wait for all the requests' do
-    t, i, m = 5, 0, Mutex.new
-    stub_request(:get, url).to_return do
-      m.synchronize{ i += 1 }
-      Thread.pass
-      {}
-    end
-
-    client = RC::Builder.client
-    t.times{ client.new.get(url) }
-    client.wait
-    client.promises.should.empty?
-    i.should.eq t
-  end
-
-  would 'wait for callback' do
-    rd, wr = IO.pipe
-    called = false
-    stub_request(:get, url).to_return(:body => 'nnf')
-    client = RC::Builder.client.new.get(url) do |nnf|
-      wr.puts
-      sleep 0.001 # make sure our callback is slow enough,
-                  # so that if `wait` is not waiting for the callback,
-                  # it would leave before the callback is completely done.
-                  # without sleeping, the callback is very likely to be
-                  # done first than `wait` anyway. raising the sleeping time
-                  # would make this test more reliable...
-      called = true
-      nil # test against returning nil, so that Promise#response is not set
-    end
-    rd.gets
-    client.wait
-    called.should.eq true
-  end
-
-  would 'cleanup promises' do
-    stub_request(:get, url).to_return(:body => 'nnf')
-    client = RC::Builder.client
-    5.times{ client.new.get(url) }
-    Thread.pass
-    GC.start # can only force GC run on MRI, so we mock for jruby and rubinius
-    stub(any_instance_of(WeakRef)).weakref_alive?{false}
-    client.new.get(url)
-    client.promises.size.should.lt 6
-    client.shutdown
-    client.promises.should.empty?
-  end
-
-  would 'have correct to_i' do
-    stub_request(:get, url).to_return(:body => '123')
-    RC::Simple.new.get(url).to_i.should.eq 123
-  end
-
-  would 'use defaults' do
-    client = RC::Builder.client do
-      use RC::Timeout, 4
-    end
-    c = client.new
-    c.timeout.should.eq 4 # default goes to middleware
-    client.extend(Module.new do
-      def default_timeout
-        3
-      end
-    end)
-    c.timeout.should.eq 4 # default is cached, so it stays the same
-    c.timeout = nil       # clear cache
-    c.timeout.should.eq 3 # now default goes to module default
-    class << client
-      def default_timeout # module defaults could be overriden
-        super - 1
-      end
-    end
-    c.timeout = nil
-    c.timeout.should.eq 2 # so it goes to class default
-    c.timeout = 1         # setup instance level value
-    c.build_env(                )['timeout'].should.eq 1 # pick instance var
-    c.build_env({'timeout' => 0})['timeout'].should.eq 0 # per-request var
-    c.timeout.should.eq 1 # won't affect underlying instance var
-    c.timeout = nil
-    c.timeout.should.eq 2 # goes back to class default
-    c.timeout = false
-    c.timeout.should.eq false # false would disable default
-  end
-
-  would 'work for inheritance' do
-    stub_request(:get, url).to_return(:body => '123')
-    Class.new(RC::Simple).new.get(url).should.eq '123'
-  end
-
-  would 'not deadlock when exception was raised in the callback' do
-    client = Class.new(RC::Simple).new
-    stub_request(:get, url).to_return(:body => 'nnf')
-
-    (-1..1).each do |size|
-      mock(any_instance_of(RC::Promise)).warn(is_a(String)) do |msg|
-        msg.should.include?('nnf')
-      end
-      client.class.pool_size = size
-      client.get(url) do |body|
-        raise body
-      end
-      client.class.shutdown
-    end
-  end
-
-  would 'be able to access caller outside the callback' do
-    client = RC::Simple.new
-    stub_request(:get, url).to_return(:body => 'nnf')
-    client.get(url) do
-      current_file = /^#{__FILE__}/
-                     caller.grep(current_file).should.empty?
-      RC::Promise.backtrace.grep(current_file).should.not.empty?
-      client.get(url) do
-        RC::Promise.backtrace.last.should.not =~ /promise\.rb:\d+:in/
-        client = nil
-      end
-    end
-    client.wait
-    client.should.nil? # to make sure the inner most block did run
-  end
-
-  would 'call error_callback' do
-    error = nil
-    error_callback = lambda{ |e| error = e }
-    should.raise(Errno::ECONNREFUSED) do
-      RC::Simple.new(:error_callback => error_callback).
-        get('http://localhost:1').tap{}
-    end
-    error.should.kind_of?(Errno::ECONNREFUSED)
-  end
-end