rest-core 1.0.3 → 2.0.0

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

@@ -1,18 +1,21 @@
 
-RestCore::Universal = RestCore::Builder.client do
-  s = RestCore
-  use s::Timeout       , 0
+module RestCore
+  Universal = Builder.client do
+    use Timeout       , 0
 
-  use s::DefaultSite   , nil
-  use s::DefaultHeaders, {}
-  use s::DefaultQuery  , {}
-  use s::AuthBasic     , nil, nil
+    use DefaultSite   , nil
+    use DefaultHeaders, {}
+    use DefaultQuery  , {}
+    use DefaultPayload, {}
+    use JsonRequest   , false
+    use AuthBasic     , nil, nil
 
-  use s::FollowRedirect, 10
-  use s::CommonLogger  , method(:puts)
-  use s::Cache         ,  {}, 600 do
-    use s::ErrorHandler, nil
-    use s::ErrorDetectorHttp
-    use s::JsonDecode  , false
+    use FollowRedirect, 10
+    use CommonLogger  , method(:puts)
+    use Cache         ,  {}, 600 do
+      use ErrorHandler, nil
+      use ErrorDetectorHttp
+      use JsonResponse, false
+    end
   end
 end

data/lib/rest-core/client_oauth1.rb

@@ -6,7 +6,7 @@ module RestCore::ClientOauth1
 
   def authorize_url! opts={}
     self.data = ParseQuery.parse_query(
-      post(request_token_path, {}, {}, {:json_decode => false}.merge(opts)))
+      post(request_token_path, {}, {}, {:json_response => false}.merge(opts)))
 
     authorize_url
   end
@@ -17,7 +17,7 @@ module RestCore::ClientOauth1
 
   def authorize! opts={}
     self.data = ParseQuery.parse_query(
-      post(access_token_path, {}, {}, {:json_decode => false}.merge(opts)))
+      post(access_token_path, {}, {}, {:json_response => false}.merge(opts)))
 
     data['authorized'] = 'true'
     data
@@ -28,12 +28,12 @@ module RestCore::ClientOauth1
   end
 
   def data_json
-    JsonDecode.json_encode(data.merge('sig' => calculate_sig))
+    Json.encode(data.merge('sig' => calculate_sig))
   end
 
   def data_json= json
-    self.data = check_sig_and_return_data(JsonDecode.json_decode(json))
-  rescue JsonDecode.const_get(:ParseError)
+    self.data = check_sig_and_return_data(Json.decode(json))
+  rescue Json.const_get(:ParseError)
     self.data = nil
   end
 

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

@@ -0,0 +1,25 @@
+
+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/{app → engine}/dry.rb

@@ -4,7 +4,6 @@ require 'rest-core/middleware'
 class RestCore::Dry
   include RestCore::Middleware
   def call env
-    env[ASYNC].call(env) if env[ASYNC]
-    env
+    yield(env)
   end
 end

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

@@ -0,0 +1,39 @@
+
+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])
+    payload = ::RestClient::Payload.generate(env[REQUEST_PAYLOAD])
+    client  = ::EventMachine::HttpRequest.new(request_uri(env)).send(
+                 env[REQUEST_METHOD],
+                 :body => payload && payload.read,
+                 :head => payload && payload.headers.
+                                               merge(env[REQUEST_HEADERS]))
+
+    client.callback{
+      future.wrap{ # callbacks are run in main thread, so we need to wrap it
+        future.on_load(client.response,
+                       client.response_header.status,
+                       client.response_header)}}
+
+    client.errback{future.wrap{ future.on_error(client.error) }}
+
+    env[TIMER].on_timeout{
+      (client.instance_variable_get(:@callbacks)||[]).clear
+      (client.instance_variable_get(:@errbacks )||[]).clear
+      client.close
+      future.wrap{ 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
+end

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

@@ -0,0 +1,106 @@
+
+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 on_load body, status, headers
+    env[TIMER].cancel if env[TIMER]
+    synchronize{
+      self.body, self.status, self.headers = body, status, headers
+      begin
+        # under ASYNC callback, should call immediate
+        next_tick{ callback } if immediate
+      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
+    }
+    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

@@ -0,0 +1,39 @@
+
+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{
+        begin
+          f.resume
+        rescue FiberError
+          # whenever timeout, it would be already resumed,
+          # and we have no way to tell if it's already resumed or not!
+        end
+      }
+    }
+    resume
+  end
+
+  protected
+  attr_accessor :fibers
+end

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

@@ -0,0 +1,29 @@
+
+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/engine/rest-client.rb

@@ -0,0 +1,56 @@
+
+require 'restclient'
+require 'rest-core/patch/rest-client'
+
+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])
+
+    t = future.wrap{ # we can implement thread pool in the future
+      begin
+        res = ::RestClient::Request.execute(:method  => env[REQUEST_METHOD ],
+                                            :url     => request_uri(env)    ,
+                                            :payload => env[REQUEST_PAYLOAD],
+                                            :headers => env[REQUEST_HEADERS],
+                                            :max_redirects => 0)
+        future.on_load(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))
+        else
+          future.on_error(e)
+        end
+      rescue Exception => e
+        future.on_error(e)
+      end
+    }
+
+    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 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
+    }
+  end
+end

data/lib/rest-core/middleware.rb

@@ -6,11 +6,16 @@ require 'cgi'
 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)
-    return unless mod.respond_to?(:members)
-    src = mod.members.map{ |member| <<-RUBY }
+    mem = if mod.respond_to?(:members) then mod.members else [] end
+    src = mem.map{ |member| <<-RUBY }
       def #{member} env
         if    env.key?('#{member}')
           env['#{member}']
@@ -19,7 +24,7 @@ module RestCore::Middleware
         end
       end
     RUBY
-    args      = [:app] + mod.members
+    args      = [:app] + mem
     para_list = args.map{ |a| "#{a}=nil"}.join(', ')
     args_list = args                     .join(', ')
     ivar_list = args.map{ |a| "@#{a}"   }.join(', ')
@@ -34,9 +39,10 @@ module RestCore::Middleware
     mod.send(:include, accessor)
   end
 
-  def call env     ; app.call(env)                               ; 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 run app=app
     if app.respond_to?(:app) && app.app
       run(app.app)
@@ -53,9 +59,25 @@ module RestCore::Middleware
     else
       q = if env[REQUEST_PATH] =~ /\?/ then '&' else '?' end
       "#{env[REQUEST_PATH]}#{q}" \
-      "#{query.map{ |(k, v)|
+      "#{query.sort.map{ |(k, v)|
         "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')}"
     end
   end
   public :request_uri
+
+  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
 end

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

@@ -5,20 +5,20 @@ class RestCore::AuthBasic
   def self.members; [:username, :password]; end
   include RestCore::Middleware
 
-  def call env
+  def call env, &k
     if username(env)
       if password(env)
         app.call(env.merge(REQUEST_HEADERS =>
-          auth_basic_header(env).merge(env[REQUEST_HEADERS] || {})))
+          auth_basic_header(env).merge(env[REQUEST_HEADERS] || {})), &k)
       else
         app.call(log(env, "AuthBasic: username provided: #{username(env)}," \
-                          " but password is missing."))
+                          " but password is missing."), &k)
       end
     elsif password(env)
       app.call(log(env, "AuthBasic: password provided: #{password(env)}," \
-                        " but username is missing."))
+                        " but username is missing."), &k)
     else
-      app.call(env)
+      app.call(env, &k)
     end
   end