rest-builder 0.9.0

data/lib/rest-builder/engine.rb

@@ -0,0 +1,57 @@
+
+require 'rest-builder/promise'
+require 'rest-builder/payload'
+require 'rest-builder/middleware'
+
+module RestBuilder
+  class Engine
+    def self.members; [:config_engine]; end
+    include Middleware
+
+    def call env, &k
+      promise = Promise.new(env[TIMER])
+      req     = env.merge(REQUEST_URI => request_uri(env), PROMISE => promise)
+
+      promise.then do |result|
+        case result
+        when Exception
+          req.merge(FAIL => env[FAIL] + [result])
+        else
+          req.merge(result)
+        end
+      end.then(&k)
+
+      pool_size = env[CLIENT].class.pool_size
+      if pool_size < 0
+        promise.call{ request(req) }
+      elsif pool_size == 0
+        promise.defer{ request(req) }
+      else
+        promise.defer(env[CLIENT].class.thread_pool){ request(req) }
+      end
+
+      req.merge(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
+end

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

@@ -0,0 +1,11 @@
+
+require 'rest-builder/middleware'
+
+module RestBuilder
+  class Dry
+    include Middleware
+    def call env
+      yield(env)
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+
+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-builder/engine'
+
+module RestBuilder
+  class HttpClient < Engine
+    private
+    def request 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, env)
+      else
+        request_sync(client, payload, headers, env)
+      end
+    end
+
+    def request_sync client, payload, headers, env
+      res = client.request(env[REQUEST_METHOD], env[REQUEST_URI], nil,
+              payload, {'User-Agent' => 'Ruby'}.merge(headers))
+
+      {RESPONSE_STATUS  => res.status,
+       RESPONSE_HEADERS => normalize_headers(res.header.all),
+       RESPONSE_BODY    => res.content}
+    end
+
+    def request_async client, payload, headers, env
+      res = client.request_async(env[REQUEST_METHOD], env[REQUEST_URI], nil,
+              payload, {'User-Agent' => 'Ruby'}.merge(headers)).pop
+
+      {RESPONSE_STATUS  => res.status,
+       RESPONSE_HEADERS => normalize_headers(res.header.all),
+       RESPONSE_BODY    => '',
+       RESPONSE_SOCKET  => res.content}
+    end
+  end
+end

data/lib/rest-builder/error.rb

@@ -0,0 +1,4 @@
+
+module RestBuilder
+  Error = Class.new(RuntimeError)
+end

data/lib/rest-builder/event_source.rb

@@ -0,0 +1,137 @@
+
+require 'thread'
+require 'rest-builder/error'
+
+module RestBuilder
+  class EventSource < Struct.new(:client, :path, :query, :opts, :socket)
+    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 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
+end

data/lib/rest-builder/middleware.rb

@@ -0,0 +1,147 @@
+
+module RestBuilder
+  module Middleware
+    METHODS_WITH_PAYLOAD = [:post, :put, :patch]
+
+    def self.included mod
+      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 || :itself.to_proc)); 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
+end

data/lib/rest-builder/payload.rb

@@ -0,0 +1,173 @@
+
+# stolen and modified from rest-client
+
+require 'stringio'
+require 'tempfile'
+
+require 'rest-builder/error'
+require 'rest-builder/middleware'
+
+begin
+  require 'mime/types/columnar'
+rescue LoadError
+  require 'mime/types'
+end
+
+module RestBuilder
+  class Payload
+    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(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
+end