rest 2.7.2 → 3.0.0

data/lib/rest/wrappers/internal_client/internal/resource.rb

@@ -0,0 +1,173 @@
+module Rest
+  module InternalClient
+    # A class that can be instantiated for access to a RESTful resource,
+    # including authentication.
+    #
+    # Example:
+    #
+    #   resource = InternalClient::Resource.new('http://some/resource')
+    #   jpg = resource.get(:accept => 'image/jpg')
+    #
+    # With HTTP basic authentication:
+    #
+    #   resource = InternalClient::Resource.new('http://protected/resource', :user => 'user', :password => 'password')
+    #   resource.delete
+    #
+    # With a timeout (seconds):
+    #
+    #   InternalClient::Resource.new('http://slow', :timeout => 10)
+    #
+    # With an open timeout (seconds):
+    #
+    #   InternalClient::Resource.new('http://behindfirewall', :open_timeout => 10)
+    #
+    # You can also use resources to share common headers. For headers keys,
+    # symbols are converted to strings. Example:
+    #
+    #   resource = InternalClient::Resource.new('http://some/resource', :headers => { :client_version => 1 })
+    #
+    # This header will be transported as X-Client-Version (notice the X prefix,
+    # capitalization and hyphens)
+    #
+    # Use the [] syntax to allocate subresources:
+    #
+    #   site = InternalClient::Resource.new('http://example.com', :user => 'adam', :password => 'mypasswd')
+    #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+    #
+    class Resource
+      attr_reader :url, :options, :block
+
+      def initialize(url, options={}, backwards_compatibility=nil, &block)
+        @url = url
+        @block = block
+        if options.class == Hash
+          @options = options
+        else # compatibility with previous versions
+          @options = {:user => options, :password => backwards_compatibility}
+        end
+      end
+
+      def get(additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        Request.execute(options.merge(
+                                                              :method => :get,
+                                                              :url => url,
+                                                              :headers => headers), &(block || @block))
+      end
+
+      def head(additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        Request.execute(options.merge(
+                                                              :method => :head,
+                                                              :url => url,
+                                                              :headers => headers), &(block || @block))
+      end
+
+      def post(payload, additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        Request.execute(options.merge(
+                                                              :method => :post,
+                                                              :url => url,
+                                                              :payload => payload,
+                                                              :headers => headers), &(block || @block))
+      end
+
+      def put(payload, additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        Request.execute(options.merge(
+                                                              :method => :put,
+                                                              :url => url,
+                                                              :payload => payload,
+                                                              :headers => headers), &(block || @block))
+      end
+
+      def patch(payload, additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        Request.execute(options.merge(
+                                                              :method => :patch,
+                                                              :url => url,
+                                                              :payload => payload,
+                                                              :headers => headers), &(block || @block))
+      end
+
+      def delete(additional_headers={}, &block)
+        headers = (options[:headers] || {}).merge(additional_headers)
+        Request.execute(options.merge(
+                                                              :method => :delete,
+                                                              :url => url,
+                                                              :headers => headers), &(block || @block))
+      end
+
+      def to_s
+        url
+      end
+
+      def user
+        options[:user]
+      end
+
+      def password
+        options[:password]
+      end
+
+      def headers
+        options[:headers] || {}
+      end
+
+      def timeout
+        options[:timeout]
+      end
+
+      def open_timeout
+        options[:open_timeout]
+      end
+
+      # Construct a subresource, preserving authentication.
+      #
+      # Example:
+      #
+      #   site = InternalClient::Resource.new('http://example.com', 'adam', 'mypasswd')
+      #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+      #
+      # This is especially useful if you wish to define your site in one place and
+      # call it in multiple locations:
+      #
+      #   def orders
+      #     InternalClient::Resource.new('http://example.com/orders', 'admin', 'mypasswd')
+      #   end
+      #
+      #   orders.get                     # GET http://example.com/orders
+      #   orders['1'].get                # GET http://example.com/orders/1
+      #   orders['1/items'].delete       # DELETE http://example.com/orders/1/items
+      #
+      # Nest resources as far as you want:
+      #
+      #   site = InternalClient::Resource.new('http://example.com')
+      #   posts = site['posts']
+      #   first_post = posts['1']
+      #   comments = first_post['comments']
+      #   comments.post 'Hello', :content_type => 'text/plain'
+      #
+      def [](suburl, &new_block)
+        case
+          when block_given? then
+            self.class.new(concat_urls(url, suburl), options, &new_block)
+          when block then
+            self.class.new(concat_urls(url, suburl), options, &block)
+          else
+            self.class.new(concat_urls(url, suburl), options)
+        end
+      end
+
+      def concat_urls(url, suburl) # :nodoc:
+        url = url.to_s
+        suburl = suburl.to_s
+        if url.slice(-1, 1) == '/' or suburl.slice(0, 1) == '/'
+          url + suburl
+        else
+          "#{url}/#{suburl}"
+        end
+      end
+    end
+  end
+end

data/lib/rest/wrappers/internal_client/internal/response.rb

@@ -0,0 +1,28 @@
+module Rest
+  module InternalClient
+
+    # A Response from InternalClient, you can access the response body, the code or the headers.
+    #
+    module Response
+
+      include AbstractResponse
+
+      attr_accessor :args, :net_http_res
+
+      attr_writer :body
+
+      def body
+        self
+      end
+
+      def Response.create body, net_http_res, args
+        result = body || ''
+        result.extend Response
+        result.net_http_res = net_http_res
+        result.args = args
+        result
+      end
+
+    end
+  end
+end

data/lib/rest/wrappers/internal_client/internal_client.rb

@@ -0,0 +1,177 @@
+require 'uri'
+require 'zlib'
+require 'stringio'
+
+begin
+  require 'net/https'
+rescue LoadError => e
+  raise e unless RUBY_PLATFORM =~ /linux/
+  raise LoadError, "no such file to load -- net/https. Try running apt-get install libopenssl-ruby"
+end
+
+require File.dirname(__FILE__) + '/internal/exceptions'
+require File.dirname(__FILE__) + '/internal/request'
+require File.dirname(__FILE__) + '/internal/abstract_response'
+require File.dirname(__FILE__) + '/internal/response'
+require File.dirname(__FILE__) + '/internal/raw_response'
+require File.dirname(__FILE__) + '/internal/resource'
+require File.dirname(__FILE__) + '/internal/payload'
+require File.dirname(__FILE__) + '/internal/net_http_ext'
+require File.dirname(__FILE__) + '/internal/mimes'
+
+# This module's static methods are the entry point for using the REST client.
+#
+#   # GET
+#   xml = InternalClient.get 'http://example.com/resource'
+#   jpg = InternalClient.get 'http://example.com/resource', :accept => 'image/jpg'
+#
+#   # authentication and SSL
+#   InternalClient.get 'https://user:password@example.com/private/resource'
+#
+#   # POST or PUT with a hash sends parameters as a urlencoded form body
+#   InternalClient.post 'http://example.com/resource', :param1 => 'one'
+#
+#   # nest hash parameters
+#   InternalClient.post 'http://example.com/resource', :nested => { :param1 => 'one' }
+#
+#   # POST and PUT with raw payloads
+#   InternalClient.post 'http://example.com/resource', 'the post body', :content_type => 'text/plain'
+#   InternalClient.post 'http://example.com/resource.xml', xml_doc
+#   InternalClient.put 'http://example.com/resource.pdf', File.read('my.pdf'), :content_type => 'application/pdf'
+#
+#   # DELETE
+#   InternalClient.delete 'http://example.com/resource'
+#
+#   # retreive the response http code and headers
+#   res = InternalClient.get 'http://example.com/some.jpg'
+#   res.code                    # => 200
+#   res.headers[:content_type]  # => 'image/jpg'
+#
+#   # HEAD
+#   InternalClient.head('http://example.com').headers
+#
+# To use with a proxy, just set InternalClient.proxy to the proper http proxy:
+#
+#   InternalClient.proxy = "http://proxy.example.com/"
+#
+# Or inherit the proxy from the environment:
+#
+#   InternalClient.proxy = ENV['http_proxy']
+#
+# For live tests of InternalClient, try using http://rest-test.heroku.com, which echoes back information about the rest call:
+#
+#   >> InternalClient.put 'http://rest-test.heroku.com/resource', :foo => 'baz'
+#   => "PUT http://rest-test.heroku.com/resource with a 7 byte payload, content type application/x-www-form-urlencoded {\"foo\"=>\"baz\"}"
+#
+module Rest
+  module InternalClient
+
+    def self.get(url, headers={}, &block)
+      Request.execute(:method => :get, :url => url, :headers => headers, &block)
+    end
+
+    def self.post(url, payload, headers={}, &block)
+      Request.execute(:method => :post, :url => url, :payload => payload, :headers => headers, &block)
+    end
+
+    def self.patch(url, payload, headers={}, &block)
+      Request.execute(:method => :patch, :url => url, :payload => payload, :headers => headers, &block)
+    end
+
+    def self.put(url, payload, headers={}, &block)
+      Request.execute(:method => :put, :url => url, :payload => payload, :headers => headers, &block)
+    end
+
+    def self.delete(url, headers={}, &block)
+      Request.execute(:method => :delete, :url => url, :headers => headers, &block)
+    end
+
+    def self.head(url, headers={}, &block)
+      Request.execute(:method => :head, :url => url, :headers => headers, &block)
+    end
+
+    def self.options(url, headers={}, &block)
+      Request.execute(:method => :options, :url => url, :headers => headers, &block)
+    end
+
+    class << self
+      attr_accessor :proxy
+    end
+
+    # Setup the log for InternalClient calls.
+    # Value should be a logger but can can be stdout, stderr, or a filename.
+    # You can also configure logging by the environment variable RESTCLIENT_LOG.
+    def self.log= log
+      @@log = create_log log
+    end
+
+    def self.version
+      version_path = File.dirname(__FILE__) + "/../VERSION"
+      return File.read(version_path).chomp if File.file?(version_path)
+      "0.0.0"
+    end
+
+    # Create a log that respond to << like a logger
+    # param can be 'stdout', 'stderr', a string (then we will log to that file) or a logger (then we return it)
+    def self.create_log param
+      if param
+        if param.is_a? String
+          if param == 'stdout'
+            stdout_logger = Class.new do
+              def << obj
+                STDOUT.puts obj
+              end
+            end
+            stdout_logger.new
+          elsif param == 'stderr'
+            stderr_logger = Class.new do
+              def << obj
+                STDERR.puts obj
+              end
+            end
+            stderr_logger.new
+          else
+            file_logger = Class.new do
+              attr_writer :target_file
+
+              def << obj
+                File.open(@target_file, 'a') { |f| f.puts obj }
+              end
+            end
+            logger = file_logger.new
+            logger.target_file = param
+            logger
+          end
+        else
+          param
+        end
+      end
+    end
+
+    @@env_log = create_log ENV['RESTCLIENT_LOG']
+
+    @@log = nil
+
+    def self.log # :nodoc:
+      @@env_log || @@log
+    end
+
+    @@before_execution_procs = []
+
+    # Add a Proc to be called before each request in executed.
+    # The proc parameters will be the http request and the request params.
+    def self.add_before_execution_proc &proc
+      @@before_execution_procs << proc
+    end
+
+    # Reset the procs to be called before each request is executed.
+    def self.reset_before_execution_procs
+      @@before_execution_procs = []
+    end
+
+    def self.before_execution_procs # :nodoc:
+      @@before_execution_procs
+    end
+
+  end
+end

data/lib/rest/wrappers/internal_client_wrapper.rb

@@ -0,0 +1,127 @@
+require_relative 'internal_client/internal_client'
+
+module Rest
+
+  module Wrappers
+    class InternalClientExceptionWrapper < HttpError
+      attr_reader :ex
+
+      def initialize(ex)
+        super(ex.response, ex.http_code)
+        @ex = ex
+      end
+    end
+
+    class InternalClientResponseWrapper < BaseResponseWrapper
+      def initialize(response)
+        @response = response
+      end
+
+      def code
+        @response.code
+      end
+
+      def body
+        @response.body
+      end
+
+      def headers_orig
+        @response.headers
+      end
+
+    end
+
+    class InternalClientWrapper < BaseWrapper
+
+      def default_headers
+        {}
+      end
+
+      def get(url, req_hash={})
+        response = nil
+        begin
+          req_hash[:method] = :get
+          req_hash[:url] = url
+          req_hash[:headers] ||= default_headers
+          req_hash[:headers][:params] = req_hash[:params] if req_hash[:params]
+          #p req_hash
+          r2 = Rest::InternalClient::Request.execute(req_hash)
+          response = InternalClientResponseWrapper.new(r2)
+        rescue Rest::InternalClient::Exception => ex
+          #p ex
+          #if ex.http_code == 404
+          #  return InternalClientResponseWrapper.new(ex.response)
+          #end
+          raise InternalClientExceptionWrapper.new(ex)
+        end
+        response
+      end
+
+      def post(url, req_hash={})
+        response = nil
+        begin
+          req_hash[:method] = :post
+          req_hash[:url] = url
+          b = req_hash[:body]
+          if b
+            if b.is_a?(Hash)
+              b = b.to_json
+            end
+            req_hash[:payload] = b
+          end
+          r2 = Rest::InternalClient::Request.execute(req_hash)
+          response = InternalClientResponseWrapper.new(r2)
+        rescue Rest::InternalClient::Exception => ex
+          raise InternalClientExceptionWrapper.new(ex)
+        end
+        response
+      end
+
+      def put(url, req_hash={})
+        response = nil
+        begin
+          req_hash[:method] = :put
+          req_hash[:url] = url
+          req_hash[:payload] = req_hash[:body] if req_hash[:body]
+          r2 = Rest::InternalClient::Request.execute(req_hash)
+          response = InternalClientResponseWrapper.new(r2)
+        rescue Rest::InternalClient::Exception => ex
+          raise InternalClientExceptionWrapper.new(ex)
+        end
+        response
+      end
+
+      def patch(url, req_hash={})
+        response = nil
+        begin
+          req_hash[:method] = :patch
+          req_hash[:url] = url
+          req_hash[:payload] = req_hash[:body] if req_hash[:body]
+          r2 = Rest::InternalClient::Request.execute(req_hash)
+          response = InternalClientResponseWrapper.new(r2)
+        rescue Rest::InternalClient::Exception => ex
+          raise InternalClientExceptionWrapper.new(ex)
+        end
+        response
+      end
+
+
+      def delete(url, req_hash={})
+        response = nil
+        begin
+          req_hash[:method] = :delete
+          req_hash[:url] = url
+          req_hash[:payload] = req_hash[:body] if req_hash[:body]
+          r2 = Rest::InternalClient::Request.execute(req_hash)
+          response = InternalClientResponseWrapper.new(r2)
+            # todo: make generic exception
+        rescue Rest::InternalClient::Exception => ex
+          raise InternalClientExceptionWrapper.new(ex)
+        end
+        response
+      end
+    end
+
+  end
+
+end