rest-core 3.6.0 → 4.0.0

data/lib/rest-core/client/simple.rb

@@ -1,2 +0,0 @@
-
-RestCore::Simple = RestCore::Builder.client

data/lib/rest-core/engine.rb

@@ -1,36 +0,0 @@
-
-require 'rest-core/promise'
-require 'rest-core/middleware'
-
-class RestCore::Engine
-  def self.members; [:config_engine]; end
-  include RestCore::Middleware
-
-  def call env, &k
-    req     = env.merge(REQUEST_URI => request_uri(env))
-    promise = Promise.new(req, k, req[ASYNC])
-    promise.defer{ request(promise, req) }
-    promise.future_response
-  end
-
-  private
-  def payload_and_headers env
-    if has_payload?(env)
-      Payload.generate_with_headers(env[REQUEST_PAYLOAD],
-                                    env[REQUEST_HEADERS])
-    else
-      [{}, env[REQUEST_HEADERS]]
-    end
-  end
-
-  def normalize_headers headers
-    headers.inject({}){ |r, (k, v)|
-      r[k.to_s.upcase.tr('-', '_')] = if v.kind_of?(Array) && v.size == 1
-                                        v.first
-                                      else
-                                        v
-                                      end
-      r
-    }
-  end
-end

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

@@ -1,9 +0,0 @@
-
-require 'rest-core/middleware'
-
-class RestCore::Dry
-  include RestCore::Middleware
-  def call env
-    yield(env)
-  end
-end

data/lib/rest-core/engine/http-client.rb

@@ -1,41 +0,0 @@
-
-require 'httpclient'
-# httpclient would require something (cookie manager) while initialized,
-# so we should try to force requiring them to avoid require deadlock!
-HTTPClient.new
-
-require 'rest-core/engine'
-
-class RestCore::HttpClient < RestCore::Engine
-  private
-  def request promise, env
-    client = ::HTTPClient.new
-    client.cookie_manager = nil
-    client.follow_redirect_count = 0
-    client.transparent_gzip_decompression = true
-    config = config_engine(env) and config.call(client)
-    payload, headers = payload_and_headers(env)
-
-    if env[HIJACK]
-      request_async(client, payload, headers, promise, env)
-    else
-      request_sync(client, payload, headers, promise, env)
-    end
-  end
-
-  def request_sync client, payload, headers, promise, env
-    res = client.request(env[REQUEST_METHOD], env[REQUEST_URI], nil,
-            payload, {'User-Agent' => 'Ruby'}.merge(headers))
-
-    promise.fulfill(res.content, res.status,
-                    normalize_headers(res.header.all))
-  end
-
-  def request_async client, payload, headers, promise, env
-    res = client.request_async(env[REQUEST_METHOD], env[REQUEST_URI], nil,
-            payload, {'User-Agent' => 'Ruby'}.merge(headers)).pop
-
-    promise.fulfill('', res.status,
-                    normalize_headers(res.header.all), res.content)
-  end
-end

data/lib/rest-core/error.rb

@@ -1,5 +0,0 @@
-
-module RestCore
-  class Error < RuntimeError
-  end
-end

data/lib/rest-core/event_source.rb

@@ -1,137 +0,0 @@
-
-require 'thread'
-require 'rest-core'
-
-class RestCore::EventSource < Struct.new(:client, :path, :query, :opts,
-                                         :socket)
-  include RestCore
-  READ_WAIT = 35
-
-  def start
-    self.mutex = Mutex.new
-    self.condv = ConditionVariable.new
-    @onopen      ||= nil
-    @onmessage   ||= nil
-    @onerror     ||= nil
-    @onreconnect ||= nil
-    @closed      ||= false
-    reconnect
-    self
-  end
-
-  def closed?
-    !!(socket && socket.closed?) || @closed
-  end
-
-  def close
-    socket && socket.close
-  rescue IOError
-  end
-
-  def wait
-    raise RC::Error.new("Not yet started for: #{self}") unless mutex
-    mutex.synchronize{ condv.wait(mutex) until closed? } unless closed?
-    self
-  end
-
-  def onopen sock=nil, &cb
-    if block_given?
-      @onopen = cb
-    else
-      self.socket = sock # for you to track the socket
-      @onopen.call(sock) if @onopen
-      onmessage_for(sock)
-    end
-    self
-  rescue Exception => e
-    begin # close the socket since we're going to stop anyway
-      sock.close # if we don't close it, client might wait forever
-    rescue IOError
-    end
-    # let the client has a chance to handle this, and make signal
-    onerror(e, sock)
-  end
-
-  def onmessage event=nil, data=nil, sock=nil, &cb
-    if block_given?
-      @onmessage = cb
-    elsif @onmessage
-      @onmessage.call(event, data, sock)
-    end
-    self
-  end
-
-  # would also be called upon closing, would always be called at least once
-  def onerror error=nil, sock=nil, &cb
-    if block_given?
-      @onerror = cb
-    else
-      begin
-        @onerror.call(error, sock) if @onerror
-        onreconnect(error, sock)
-      rescue Exception
-        mutex.synchronize do
-          @closed = true
-          condv.signal # so we can't be reconnecting, need to try to unblock
-        end
-        raise
-      end
-    end
-    self
-  end
-
-  # would be called upon closing,
-  # and would try to reconnect if a callback is set and return true
-  def onreconnect error=nil, sock=nil, &cb
-    if block_given?
-      @onreconnect = cb
-    elsif closed? && @onreconnect && @onreconnect.call(error, sock)
-      reconnect
-    else
-      mutex.synchronize do
-        @closed = true
-        condv.signal # we could be closing, let's try to unblock it
-      end
-    end
-    self
-  end
-
-  protected
-  attr_accessor :mutex, :condv
-
-  private
-  # called in requesting thread after the request is done
-  def onmessage_for sock
-    while IO.select([sock], [], [], READ_WAIT)
-      event = sock.readline("\n\n").split("\n").inject({}) do |r, i|
-        k, v = i.split(': ', 2)
-        r[k] = v
-        r
-      end
-      onmessage(event['event'], event['data'], sock)
-    end
-    close_sock(sock)
-    onerror(EOFError.new, sock)
-  rescue IOError, SystemCallError => e
-    close_sock(sock)
-    onerror(e, sock)
-  end
-
-  def close_sock sock
-    sock.close
-  rescue IOError => e
-    onerror(e, sock)
-  end
-
-  def reconnect
-    o = {REQUEST_HEADERS => {'Accept' => 'text/event-stream'},
-         HIJACK          => true}.merge(opts)
-    client.get(path, query, o) do |sock|
-      if sock.nil? || sock.kind_of?(Exception)
-        onerror(sock)
-      else
-        onopen(sock)
-      end
-    end
-  end
-end

data/lib/rest-core/middleware.rb

@@ -1,151 +0,0 @@
-
-require 'uri'
-require 'rest-core'
-
-module RestCore::Middleware
-  include RestCore
-  METHODS_WITH_PAYLOAD = [:post, :put, :patch]
-
-  def self.included mod
-    mod.send(:include, RestCore)
-    mod.send(:attr_reader, :app)
-    mem = if mod.respond_to?(:members) then mod.members else [] end
-    src = mem.map{ |member| <<-RUBY }
-      attr_writer :#{member}
-      def #{member} env
-        if    env.key?('#{member}')
-          env['#{member}']
-        else
-              @#{member}
-        end
-      end
-    RUBY
-    args      = [:app] + mem
-    para_list = args.map{ |a| "#{a}=nil"}.join(', ')
-    args_list = args                     .join(', ')
-    ivar_list = args.map{ |a| "@#{a}"   }.join(', ')
-    src << <<-RUBY
-      def initialize #{para_list}
-        #{ivar_list} = #{args_list}
-      end
-    RUBY
-    accessor = Module.new
-    accessor.module_eval(src.join("\n"), __FILE__, __LINE__)
-    mod.const_set(:Accessor, accessor)
-    mod.send(:include, accessor)
-  end
-
-  def call env, &k; app.call(env, &(k || id)); end
-  def id          ; RC.id                    ; end
-  def fail env, obj
-    if obj
-      env.merge(FAIL => (env[FAIL] || []) + [obj])
-    else
-      env
-    end
-  end
-  def log env, obj
-    if obj
-      env.merge(LOG  => (env[LOG]  || []) + [obj])
-    else
-      env
-    end
-  end
-  def run a=app
-    if a.respond_to?(:app) && a.app
-      run(a.app)
-    else
-      a
-    end
-  end
-  def error_callback res, err
-    res[CLIENT].error_callback.call(err) if
-      res[CLIENT] && res[CLIENT].error_callback
-  end
-  def give_promise res
-    res[CLIENT].give_promise(res) if res[CLIENT]
-  end
-
-  module_function
-  def request_uri env
-    # compacting the hash
-    if (query = (env[REQUEST_QUERY] || {}).select{ |k, v| v }).empty?
-      env[REQUEST_PATH].to_s
-    else
-      q = if env[REQUEST_PATH] =~ /\?/ then '&' else '?' end
-      "#{env[REQUEST_PATH]}#{q}#{percent_encode(query)}"
-    end
-  end
-  public :request_uri
-
-  def percent_encode query
-    query.sort.map{ |(k, v)|
-      if v.kind_of?(Array)
-        v.map{ |vv| "#{escape(k.to_s)}=#{escape(vv.to_s)}" }.join('&')
-      else
-        "#{escape(k.to_s)}=#{escape(v.to_s)}"
-      end
-    }.join('&')
-  end
-  public :percent_encode
-
-  UNRESERVED = /[^a-zA-Z0-9\-\.\_\~]+/
-  def escape string
-    string.gsub(UNRESERVED) do |s|
-      "%#{s.unpack('H2' * s.bytesize).join('%')}".upcase
-    end
-  end
-  public :escape
-
-  def has_payload? env
-    METHODS_WITH_PAYLOAD.include?(env[REQUEST_METHOD])
-  end
-  public :has_payload?
-
-  def contain_binary? payload
-    return false unless payload
-    return true  if     payload.respond_to?(:read)
-    return true  if     payload.find{ |k, v|
-      # if payload is an array, then v would be nil
-      (v || k).respond_to?(:read) ||
-      # if v is an array, it could contain binary data
-      (v.kind_of?(Array) && v.any?{ |vv| vv.respond_to?(:read) }) }
-    return false
-  end
-  public :contain_binary?
-
-  def string_keys hash
-    hash.inject({}){ |r, (k, v)|
-      if v.kind_of?(Hash)
-        r[k.to_s] = case k.to_s
-                      when REQUEST_QUERY, REQUEST_PAYLOAD, REQUEST_HEADERS
-                        string_keys(v)
-                      else;         v
-                    end
-      else
-        r[k.to_s] = v
-      end
-      r
-    }
-  end
-  public :string_keys
-
-  # this method is intended to merge payloads if they are non-empty hashes,
-  # but prefer the right most one if they are not hashes.
-  def merge_hash *hashes
-    hashes.reverse_each.inject do |r, i|
-      if r.kind_of?(Hash)
-        if i.kind_of?(Hash)
-          Middleware.string_keys(i).merge(Middleware.string_keys(r))
-        elsif r.empty?
-          i # prefer non-empty ones
-        else
-          r # don't try to merge non-hashes
-        end
-      else
-        r
-      end
-    end
-  end
-  public :merge_hash
-end

data/lib/rest-core/promise.rb

@@ -1,249 +0,0 @@
-
-require 'thread'
-require 'rest-core'
-
-class RestCore::Promise
-  include RestCore
-
-  class Future < BasicObject
-    def initialize promise, target
-      @promise, @target = promise, target
-    end
-
-    def method_missing msg, *args, &block
-      @promise.yield[@target].__send__(msg, *args, &block)
-    end
-  end
-
-  def self.claim env, k=RC.id, body, status, headers
-    promise = new(env, k, env[ASYNC])
-    promise.fulfill(body, status, headers)
-    promise
-  end
-
-  def self.backtrace
-    Thread.current[:backtrace] || []
-  end
-
-  # should never raise!
-  def self.set_backtrace e
-    e.set_backtrace((e.backtrace || caller) + backtrace)
-  end
-
-  def initialize env, k=RC.id, immediate=false, &job
-    self.env       = env
-    self.k         = [k]
-    self.immediate = immediate
-
-    self.body, self.status, self.headers, self.socket,
-      self.response, self.error, self.called = nil
-
-    self.condv     = ConditionVariable.new
-    self.mutex     = Mutex.new
-
-    defer(&job) if job
-  end
-
-  def inspect
-    "<#{self.class.name} for #{env[REQUEST_URI]}>"
-  end
-
-  def future_body    ; Future.new(self, RESPONSE_BODY   ); end
-  def future_status  ; Future.new(self, RESPONSE_STATUS ); end
-  def future_headers ; Future.new(self, RESPONSE_HEADERS); end
-  def future_socket  ; Future.new(self, RESPONSE_SOCKET ); end
-  def future_failures; Future.new(self, FAIL)            ; end
-  def future_response
-    env.merge(RESPONSE_BODY    => future_body,
-              RESPONSE_STATUS  => future_status,
-              RESPONSE_HEADERS => future_headers,
-              RESPONSE_SOCKET  => future_socket,
-              FAIL             => future_failures,
-              PROMISE          => self)
-  end
-
-  # called in client thread
-  def defer
-    if pool_size < 0 # negative number for blocking call
-      self.thread = Thread.current # set working thread
-      protected_yield{ yield } # avoid any exception and do the job
-    else
-      backtrace = caller + self.class.backtrace # retain the backtrace so far
-      if pool_size > 0
-        mutex.synchronize do
-          # still timing it out if the task never processed
-          env[TIMER].on_timeout{ cancel_task } if env[TIMER]
-          self.task = client_class.thread_pool.defer(mutex) do
-            Thread.current[:backtrace] = backtrace
-            protected_yield{ yield }
-            Thread.current[:backtrace] = nil
-          end
-        end
-      else
-        self.thread = Thread.new do
-          Thread.current[:backtrace] = backtrace
-          protected_yield{ yield }
-        end
-      end
-    end
-  end
-
-  # called in client thread (client.wait)
-  def wait
-    # it might be awaken by some other futures!
-    mutex.synchronize{ condv.wait(mutex) until done? } unless done?
-  end
-
-  # called in client thread (from the future (e.g. body))
-  def yield
-    wait
-    callback
-  end
-
-  # called in requesting thread after the request is done
-  def fulfill body, status, headers, socket=nil
-    env[TIMER].cancel if env[TIMER]
-    mutex.synchronize{ fulfilling(body, status, headers, socket) }
-  end
-
-  # called in requesting thread if something goes wrong or timed out
-  def reject error
-    env[TIMER].cancel if env[TIMER]
-    mutex.synchronize{ rejecting(error) }
-  end
-
-  # append your actions, which would be called when we're calling back
-  def then &action
-    k << action
-    self
-  end
-
-  # called in Client.defer to mark this promise as done
-  def done body=''
-    fulfill(body, 0, {})
-  end
-
-  # It's considered done only if the HTTP request is done, and we're not
-  # in asynchronous mode otherwise the callback should be called first.
-  # For synchronous mode, since we're waiting for the callback anyway,
-  # we don't really have to check if it's called.
-  def done?
-    !!status && (!immediate || called)
-  end
-
-  protected
-  attr_accessor :env, :k, :immediate,
-                :body, :status, :headers, :socket,
-                :response, :error, :called,
-                :condv, :mutex, :task, :thread
-
-  private
-  def fulfilling body, status, headers, socket=nil
-    self.body, self.status, self.headers, self.socket =
-      body, status, headers, socket
-    # under ASYNC callback, should call immediately
-    callback if immediate
-  ensure
-    condv.broadcast # client or response might be waiting
-  end
-
-  def rejecting error
-    self.error = if error.kind_of?(Exception)
-                   error
-                 else
-                   Error.new(error || 'unknown')
-                 end
-    fulfilling('', 0, {})
-  end
-
-  # called in a new thread if pool_size == 0, otherwise from the pool
-  # i.e. requesting thread
-  def protected_yield
-    if env[TIMER]
-      timeout_protected_yield{ yield }
-    else
-      yield
-    end
-  rescue Exception => e
-    mutex.synchronize do
-      self.class.set_backtrace(e)
-      if done? # log user callback error
-        callback_error(e)
-      else # IOError, SystemCallError, etc
-        begin
-          rejecting(e) # would call user callback
-        rescue Exception => f # log user callback error
-          callback_error(f){ self.class.set_backtrace(f) }
-        end
-      end
-    end
-  end
-
-  def timeout_protected_yield
-    # timeout might already be set for thread_pool (pool_size > 0)
-    env[TIMER].on_timeout{ cancel_task } unless env[TIMER].timer
-    yield
-  ensure
-    env[TIMER].cancel
-  end
-
-  # called in client thread, when yield is called
-  def callback
-    return response if called
-    self.response = k.inject(
-      env.merge(RESPONSE_BODY    => body  ,
-                RESPONSE_STATUS  => status,
-                RESPONSE_HEADERS => headers,
-                RESPONSE_SOCKET  => socket,
-                FAIL             => ((env[FAIL]||[]) + [error]).compact,
-                LOG              =>   env[LOG] ||[])){ |r, i| i.call(r) }
-  ensure
-    self.called = true
-  end
-
-  # log user callback error
-  def callback_error e
-    never_raise_yield do
-      yield if block_given?
-      if env[CLIENT].error_callback
-        env[CLIENT].error_callback.call(e)
-      else
-        warn "RestCore: ERROR: #{e}\n  from #{e.backtrace.inspect}"
-      end
-    end
-  end
-
-  # timeout!
-  def cancel_task backtrace=nil
-    mutex.synchronize do
-      next if done? # don't cancel if it's done
-      if t = thread || task.thread
-        t.raise(env[TIMER].error) # raise Timeout::Error to working thread
-      else    # task was queued and never started, just cancel it and
-        begin # fulfill the promise with Timeout::Error
-          task.cancel
-          rejecting(env[TIMER].error)
-        rescue Exception => e # log user callback error
-          callback_error(e){e.set_backtrace(e.backtrace + (backtrace || []))}
-        end
-      end
-    end
-  end
-
-  # only use this for unimportant stuffs and in most critical section
-  # e.g. error logging in critical section
-  def never_raise_yield
-    yield
-  rescue Exception => e
-    Thread.main.raise(e) if !!$DEBUG
-  end
-
-  def client_class; env[CLIENT].class; end
-  def pool_size
-    @pool_size ||= if client_class.respond_to?(:pool_size)
-                     client_class.pool_size
-                   else
-                     0
-                   end
-  end
-end