rest-core 2.1.2 → 3.0.0

data/lib/rest-core/engine.rb

@@ -0,0 +1,39 @@
+
+require 'rest-core/promise'
+require 'rest-core/middleware'
+
+class RestCore::Engine
+  include RestCore::Middleware
+
+  def call env, &k
+    promise = Promise.new(env, k, env[ASYNC])
+    promise.defer{ request(promise, env) }
+    env.merge(RESPONSE_BODY    => promise.future_body,
+              RESPONSE_STATUS  => promise.future_status,
+              RESPONSE_HEADERS => promise.future_headers,
+              RESPONSE_SOCKET  => promise.future_socket,
+              FAIL             => promise.future_failures,
+              PROMISE          => promise)
+  end
+
+  private
+  def payload_and_headers env
+    Payload.generate_with_headers(env[REQUEST_PAYLOAD], env[REQUEST_HEADERS])
+  end
+
+  def calculate_timeout timer
+    return [] unless timer
+    [timer.timeout, timer.timeout]
+  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/http-client.rb

@@ -0,0 +1,41 @@
+
+require 'httpclient'
+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
+    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
+  rescue Exception => e
+    promise.reject(e)
+  end
+
+  def request_sync client, payload, headers, promise, env
+    client.connect_timeout, client.receive_timeout =
+      calculate_timeout(env[TIMER])
+
+    res = client.request(env[REQUEST_METHOD], request_uri(env), 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], request_uri(env), 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/engine/net-http-persistent.rb

@@ -0,0 +1,21 @@
+
+require 'net/http/persistent'
+require 'rest-core/engine'
+
+class RestCore::NetHttpPersistent < RestCore::Engine
+  def request promise, env
+    http = ::Net::HTTP::Persistent.new
+    http.open_timeout, http.read_timeout = calculate_timeout(env[TIMER])
+    payload, headers = payload_and_headers(env)
+
+    uri = ::URI.parse(request_uri(env))
+    req = ::Net::HTTP.const_get(env[REQUEST_METHOD].to_s.capitalize).
+            new(uri, headers)
+    req.body_stream = payload
+    res = http.request(uri, req)
+
+    promise.fulfill(res.body, res.code.to_i, normalize_headers(res.to_hash))
+  rescue Exception => e
+    promise.reject(e)
+  end
+end

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

@@ -1,58 +1,29 @@
 
 require 'restclient'
 require 'rest-core/patch/rest-client'
+require 'rest-core/engine'
 
-require 'rest-core/engine/future/future'
-require 'rest-core/middleware'
-
-class RestCore::RestClient
-  include RestCore::Middleware
-  def call env, &k
-    future  = Future::FutureThread.new(env, k, env[ASYNC])
-
-    # we can implement thread pool in the future
-    t = future.wrap{ request(future, env) }
-
-    env[TIMER].on_timeout{
-      t.kill
-      future.on_error(env[TIMER].error)
-    } if env[TIMER]
-
-    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])
+class RestCore::RestClient < RestCore::Engine
+  def request promise, env
+    open_timeout, read_timeout = calculate_timeout(env[TIMER])
+    payload, headers = payload_and_headers(env)
     res = ::RestClient::Request.execute(:method   => env[REQUEST_METHOD],
                                         :url      => request_uri(env)   ,
                                         :payload  => payload            ,
                                         :headers  => headers            ,
-                                        :max_redirects => 0)
-    future.on_load(res.body, res.code, normalize_headers(res.raw_headers))
-
+                                        :max_redirects => 0             ,
+                                        :open_timeout => open_timeout   ,
+                                             :timeout => read_timeout   )
+    promise.fulfill(res.body, res.code, normalize_headers(res.raw_headers))
   rescue ::RestClient::Exception => e
     if res = e.response
       # we don't want to raise an exception for 404 requests
-      future.on_load(res.body, res.code, normalize_headers(res.raw_headers))
+      promise.fulfill(res.body, res.code, normalize_headers(res.raw_headers))
     else
-      future.on_error(e)
+      promise.reject(e)
     end
-  rescue Exception => e
-    future.on_error(e)
-  end
 
-  def normalize_headers raw_headers
-    raw_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
-    }
+  rescue Exception => e
+    promise.reject(e)
   end
 end

data/lib/rest-core/event_source.rb

@@ -0,0 +1,91 @@
+
+require 'thread'
+require 'rest-core'
+
+class RestCore::EventSource < Struct.new(:client, :path, :query, :opts,
+                                         :socket)
+  include RestCore
+  def start
+    self.mutex = Mutex.new
+    self.condv = ConditionVariable.new
+    @onopen        ||= nil
+    @onmessage_for ||= nil
+    @onerror       ||= nil
+
+    o = {REQUEST_HEADERS => {'Accept' => 'text/event-stream'},
+         HIJACK          => true}.merge(opts)
+    client.get(path, query, o){ |sock| onopen(sock) }
+  end
+
+  def closed?
+    !!(socket && socket.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?
+  end
+
+  def onopen sock=nil, &cb
+    if block_given?
+      @onopen = cb
+    else
+      @onopen.call(sock) if @onopen
+      onmessage_for(sock)
+    end
+  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, sock=nil, &cb
+    if block_given?
+      @onmessage = cb
+    elsif @onmessage
+      @onmessage.call(event, sock)
+    end
+  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
+      ensure
+        condv.signal # should never deadlock someone
+      end
+    end
+  end
+
+  protected
+  attr_accessor :mutex, :condv
+
+  private
+  # called in requesting thread after the request is done
+  def onmessage_for sock
+    self.socket = sock # for you to track the socket
+    until sock.eof?
+      event = sock.readline("\n\n").split("\n").inject({}) do |r, i|
+        k, v = i.split(': ', 2)
+        r[k] = v
+        r
+      end
+      onmessage(event, sock)
+    end
+    sock.close
+    onerror(EOFError.new, sock)
+  rescue IOError => e
+    onerror(e, sock)
+  end
+end

data/lib/rest-core/middleware.rb

@@ -1,16 +1,10 @@
 
-require 'rest-core'
-
 require 'uri'
+require 'rest-core'
 
 module RestCore::Middleware
   include RestCore
 
-  # identity function
-  def self.id
-    @id ||= lambda{ |a| a }
-  end
-
   def self.included mod
     mod.send(:include, RestCore)
     mod.send(:attr_reader, :app)
@@ -39,10 +33,22 @@ module RestCore::Middleware
     mod.send(:include, accessor)
   end
 
-  def call env,  &k; app.call(env, &(k || id))                   ; end
-  def fail env, obj; env.merge(FAIL => (env[FAIL] || []) + [obj]); end
-  def log  env, obj; env.merge(LOG  => (env[LOG]  || []) + [obj]); end
-  def id           ; Middleware.id                               ; 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 app=app
     if app.respond_to?(:app) && app.app
       run(app.app)

data/lib/rest-core/middleware/error_detector.rb

@@ -8,12 +8,7 @@ class RestCore::ErrorDetector
   def call env
     app.call(env){ |response|
       detector = error_detector(env)
-      yield(
-        if error = (detector && detector.call(response))
-          fail(response, error)
-        else
-          response
-        end)
+      yield(fail(response, detector && detector.call(response)))
     }
   end
 end

data/lib/rest-core/middleware/oauth1_header.rb

@@ -5,6 +5,7 @@ require 'rest-core/util/hmac'
 require 'uri'
 require 'openssl'
 
+# http://tools.ietf.org/html/rfc5849
 class RestCore::Oauth1Header
   def self.members
     [:request_token_path, :access_token_path, :authorize_path,

data/lib/rest-core/middleware/oauth2_header.rb

@@ -1,21 +1,33 @@
 
 require 'rest-core/middleware'
 
+# http://tools.ietf.org/html/rfc6749
 class RestCore::Oauth2Header
   def self.members; [:access_token_type, :access_token]; end
   include RestCore::Middleware
 
   def call env, &k
     start_time = Time.now
-    headers = {'Authorization' =>
-                 "#{access_token_type(env)} #{access_token(env)}"}.
-                merge(env[REQUEST_HEADERS]) if access_token(env)
+    headers    = build_headers(env)
+    auth       = headers['Authorization']
+    event      = Event::WithHeader.new(Time.now - start_time,
+                   "Authorization: #{auth}") if auth
 
-    event = Event::WithHeader.new(Time.now - start_time,
-              "Authorization: #{headers['Authorization']}") if headers
+    app.call(log(env.merge(REQUEST_HEADERS => headers), event), &k)
+  end
+
+  def build_headers env
+    auth = case token = access_token(env)
+           when String
+             token
+           when Hash
+            token.map{ |(k, v)| "#{k}=\"#{v}\"" }.join(', ')
+           end
 
-    app.call(log(env.merge(REQUEST_HEADERS => headers ||
-                                              env[REQUEST_HEADERS]), event),
-             &k)
+    if auth
+      {'Authorization' => "#{access_token_type(env)} #{auth}"}
+    else
+      {}
+    end.merge(env[REQUEST_HEADERS])
   end
 end

data/lib/rest-core/middleware/oauth2_query.rb

@@ -1,6 +1,7 @@
 
 require 'rest-core/middleware'
 
+# http://tools.ietf.org/html/rfc6749
 class RestCore::Oauth2Query
   def self.members; [:access_token]; end
   include RestCore::Middleware

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

@@ -1,7 +1,6 @@
 
 require 'rest-core/middleware'
-
-require 'timeout'
+require 'rest-core/timer'
 
 class RestCore::Timeout
   def self.members; [:timeout]; end
@@ -22,27 +21,14 @@ class RestCore::Timeout
   end
 
   def monitor env
-    class_name = case name = run.class.to_s
-                 when /Auto/
-                   run.http_client.class.to_s
-                 else
-                   name
-                 end
-
-    timer = case class_name
-            when /EmHttpRequest/
-              TimerEm
-            else
-              TimerThread
-            end.new(timeout(env), timeout_error)
-
+    timer = Timer.new(timeout(env), timeout_error)
     yield(env.merge(TIMER => timer))
+  rescue Exception
+    timer.cancel
+    raise
   end
 
   def timeout_error
     ::Timeout::Error.new('execution expired')
   end
-
-  autoload :TimerEm    , 'rest-core/middleware/timeout/timer_em'
-  autoload :TimerThread, 'rest-core/middleware/timeout/timer_thread'
 end

data/lib/rest-core/promise.rb

@@ -0,0 +1,137 @@
+
+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 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, = nil
+
+    self.condv     = ConditionVariable.new
+    self.mutex     = Mutex.new
+
+    defer(&job) if job
+  end
+
+  def inspect
+    "<#{self.class.name} for #{env[REQUEST_PATH]}>"
+  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
+
+  # called in client thread
+  def defer &job
+    if pool_size < 0 # negative number for blocking call
+      job.call
+    elsif pool_size > 0
+      self.task = client_class.thread_pool.defer do
+        synchronized_yield{ job.call }
+      end
+    else
+      Thread.new{ synchronized_yield{ job.call } }
+    end
+    env[TIMER].on_timeout{ reject(env[TIMER].error) } if env[TIMER]
+  end
+
+  # called in client thread (client.wait)
+  def wait
+    # it might be awaken by some other futures!
+    mutex.synchronize{ condv.wait(mutex) until !!status } unless !!status
+  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]
+    self.body, self.status, self.headers, self.socket =
+      body, status, headers, socket
+    # under ASYNC callback, should call immediately
+    callback_in_async if immediate
+    condv.broadcast # client or response might be waiting
+  end
+
+  # called in requesting thread if something goes wrong or timed out
+  def reject error
+    task.cancel if task
+
+    self.error = if error.kind_of?(Exception)
+                   error
+                 else
+                   Error.new(error || 'unknown')
+                 end
+    fulfill('', 0, {})
+  end
+
+  protected
+  attr_accessor :env, :k, :immediate,
+                :response, :body, :status, :headers, :socket, :error,
+                :condv, :mutex, :task
+
+  private
+  # called in a new thread if pool_size == 0, otherwise from the pool
+  # i.e. requesting thread
+  def synchronized_yield
+    mutex.synchronize{ yield }
+  rescue Exception => e
+    # nothing we can do here for an asynchronous exception,
+    # so we just log the error
+    # TODO: add error_log_method
+    warn "RestCore: ERROR: #{e}\n  from #{e.backtrace.inspect}"
+    reject(e)   # should never deadlock someone
+  end
+
+  # called in client thread, when yield is called
+  def callback
+    self.response ||= k.call(
+      env.merge(RESPONSE_BODY    => body  ,
+                RESPONSE_STATUS  => status,
+                RESPONSE_HEADERS => headers,
+                RESPONSE_SOCKET  => socket,
+                FAIL             => ((env[FAIL]||[]) + [error]).compact,
+                LOG              =>   env[LOG] ||[]))
+  end
+
+  # called in requesting thread, whenever the request is done
+  def callback_in_async
+    callback
+  rescue Exception => e
+    # nothing we can do here for an asynchronous exception,
+    # so we just log the error
+    # TODO: add error_log_method
+    warn "RestCore: ERROR: #{e}\n  from #{e.backtrace.inspect}"
+  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