cs-httpi 0.9.5.1

data/lib/cs-httpi/auth/ssl.rb

@@ -0,0 +1,91 @@
+require "openssl"
+
+module HTTPI
+  module Auth
+
+    # = HTTPI::Auth::SSL
+    #
+    # Provides SSL client authentication.
+    class SSL
+
+      VERIFY_MODES = [:none, :peer, :fail_if_no_peer_cert, :client_once]
+      CERT_TYPES = [:pem, :der]
+
+      # Returns whether SSL configuration is present.
+      def present?
+        (verify_mode == :none) || (cert && cert_key)
+      rescue TypeError, Errno::ENOENT
+        false
+      end
+
+      # Accessor for the cert key file to validate SSL certificates.
+      attr_accessor :cert_key_file
+
+      # Accessor for the cert key password to validate SSL certificates.
+      attr_accessor :cert_key_password
+
+      # Accessor for the cert file to validate SSL connections.
+      attr_accessor :cert_file
+
+      # Accessor for the cacert file to validate SSL certificates.
+      attr_accessor :ca_cert_file
+
+      # Returns the cert type to validate SSL certificates PEM|DER.
+      def cert_type
+        @cert_type ||= :pem
+      end
+
+      # Sets the cert type to validate SSL certificates PEM|DER.
+      def cert_type=(type)
+        raise ArgumentError, "Invalid SSL cert type: #{type}" unless CERT_TYPES.include? type
+        @cert_type = type
+      end
+
+      # Returns the SSL verify mode. Defaults to <tt>:peer</tt>.
+      def verify_mode
+        @verify_mode ||= :peer
+      end
+
+      # Sets the SSL verify mode. Expects one of <tt>HTTPI::Auth::SSL::VERIFY_MODES</tt>.
+      def verify_mode=(mode)
+        raise ArgumentError, "Invalid SSL verify mode: #{mode}" unless VERIFY_MODES.include? mode
+        @verify_mode = mode
+      end
+
+      # Returns an <tt>OpenSSL::X509::Certificate</tt> for the +cert_file+.
+      def cert
+        @cert ||= OpenSSL::X509::Certificate.new File.read(cert_file) if cert_file
+      end
+
+      # Sets the +OpenSSL+ certificate.
+      attr_writer :cert
+
+      # Returns an <tt>OpenSSL::X509::Certificate</tt> for the +ca_cert_file+.
+      def ca_cert
+        @ca_cert ||= OpenSSL::X509::Certificate.new File.read(ca_cert_file)
+      end
+
+      # Sets the +OpenSSL+ ca certificate.
+      attr_writer :ca_cert
+
+      # Returns an <tt>OpenSSL::PKey::RSA</tt> for the +cert_key_file+.
+      def cert_key
+        @cert_key ||= OpenSSL::PKey::RSA.new(File.read(cert_key_file), cert_key_password) if cert_key_file
+      end
+
+      # Sets the +OpenSSL+ certificate key.
+      attr_writer :cert_key
+
+      # Returns the SSL verify mode as a <tt>OpenSSL::SSL::VERIFY_*</tt> constant.
+      def openssl_verify_mode
+        case verify_mode
+          when :none                 then OpenSSL::SSL::VERIFY_NONE
+          when :peer                 then OpenSSL::SSL::VERIFY_PEER
+          when :fail_if_no_peer_cert then OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+          when :client_once          then OpenSSL::SSL::VERIFY_CLIENT_ONCE
+        end
+      end
+
+    end
+  end
+end

data/lib/cs-httpi/dime.rb

@@ -0,0 +1,56 @@
+module HTTPI
+  class DimeRecord < Struct.new('DimeRecord', :version, :first, :last, :chunked, :type_format, :options, :id, :type, :data)
+  end
+
+  class Dime < Array
+    BINARY = 1
+    XML = 2
+
+    def initialize(body)
+      bytes = body.unpack('C*')
+
+      while bytes.length > 0
+        record = DimeRecord.new
+
+        # Shift out bitfields for the first fields
+        byte = bytes.shift
+        record.version     = (byte >> 3) & 31         # 5 bits  DIME format version (always 1)
+        record.first       = (byte >> 2) & 1          # 1 bit   Set if this is the first part in the message
+        record.last        = (byte >> 1) & 1          # 1 bit   Set if this is the last part in the message
+        record.chunked     = byte & 1                 # 1 bit   This file is broken into chunked parts
+        record.type_format = (bytes.shift >> 4) & 15  # 4 bits  Type of file in the part (1 for binary data, 2 for XML)
+                                                      # 4 bits  Reserved (skipped in the above command)
+
+        # Fetch big-endian lengths
+        lengths = [] # we can't use a hash since the order will be screwed in Ruby 1.8
+        lengths << [:options, (bytes.shift << 8) | bytes.shift]                                             # 2 bytes   Length of the "options" field
+        lengths << [:id,      (bytes.shift << 8) | bytes.shift]                                             # 2 bytes   Length of the "ID" or "name" field
+        lengths << [:type,    (bytes.shift << 8) | bytes.shift]                                             # 2 bytes   Length of the "type" field
+        lengths << [:data,    (bytes.shift << 24) | (bytes.shift << 16) | (bytes.shift << 8) | bytes.shift] # 4 bytes   Size of the included file
+
+        # Read in padded data
+        lengths.each do |attribute_set|
+          attribute, length = attribute_set
+          content = bytes.slice!(0, length).pack('C*')
+          if attribute == :data && record.type_format == BINARY
+            content = StringIO.new(content)
+          end
+
+          record.send "#{attribute.to_s}=", content
+
+          bytes.slice!(0, 4 - (length & 3)) if (length & 3) != 0
+        end
+
+        self << record
+      end
+    end
+
+    def xml_records
+      select { |r| r.type_format == XML }
+    end
+
+    def binary_records
+      select { |r| r.type_format == BINARY }
+    end
+  end
+end

data/lib/cs-httpi/request.rb

@@ -0,0 +1,99 @@
+require "uri"
+require "cs-httpi/auth/config"
+require "rack/utils"
+
+module HTTPI
+
+  # = HTTPI::Request
+  #
+  # Represents an HTTP request and contains various methods for customizing that request.
+  class Request
+
+    # Available attribute writers.
+    ATTRIBUTES = [:url, :proxy, :headers, :body, :open_timeout, :read_timeout]
+
+    # Accepts a Hash of +args+ to mass assign attributes and authentication credentials.
+    def initialize(args = {})
+      if args.kind_of? String
+        self.url = args
+      elsif args.kind_of?(Hash) && !args.empty?
+        mass_assign args
+      end
+    end
+
+    # Sets the +url+ to access. Raises an +ArgumentError+ unless the +url+ is valid.
+    def url=(url)
+      @url = normalize_url! url
+    end
+
+    # Returns the +url+ to access.
+    attr_reader :url
+
+    # Sets the +proxy+ to use. Raises an +ArgumentError+ unless the +proxy+ is valid.
+    def proxy=(proxy)
+      @proxy = normalize_url! proxy
+    end
+
+    # Returns the +proxy+ to use.
+    attr_reader :proxy
+
+    # Returns whether to use SSL.
+    def ssl?
+      return @ssl unless @ssl.nil?
+      !!(url.to_s =~ /^https/)
+    end
+
+    # Sets whether to use SSL.
+    attr_writer :ssl
+
+    # Returns a Hash of HTTP headers. Defaults to return an empty Hash.
+    def headers
+      @headers ||= Rack::Utils::HeaderHash.new
+    end
+
+    # Sets the Hash of HTTP headers.
+    def headers=(headers)
+      @headers = Rack::Utils::HeaderHash.new(headers)
+    end
+
+    # Adds a header information to accept gzipped content.
+    def gzip
+      headers["Accept-Encoding"] = "gzip,deflate"
+    end
+
+    attr_accessor :open_timeout, :read_timeout
+    attr_reader :body
+
+    def body=(new_value)
+      if new_value.is_a?(Hash)
+        @body = new_value.map {|k,v| "#{k}=#{v}" }.join "&"
+      else
+        @body = new_value
+      end
+    end
+
+    # Returns the <tt>HTTPI::Authentication</tt> object.
+    def auth
+      @auth ||= Auth::Config.new
+    end
+
+    # Returns whether any authentication credentials were specified.
+    def auth?
+      !!auth.type
+    end
+
+    # Expects a Hash of +args+ to assign.
+    def mass_assign(args)
+      ATTRIBUTES.each { |key| send("#{key}=", args[key]) if args[key] }
+    end
+
+  private
+
+    # Expects a +url+, validates its validity and returns a +URI+ object.
+    def normalize_url!(url)
+      raise ArgumentError, "Invalid URL: #{url}" unless url.to_s =~ /^http/
+      url.kind_of?(URI) ? url : URI(url)
+    end
+
+  end
+end

data/lib/cs-httpi/response.rb

@@ -0,0 +1,85 @@
+require "zlib"
+require "stringio"
+require "cs-httpi/dime"
+require "rack/utils"
+
+module HTTPI
+
+  # = HTTPI::Response
+  #
+  # Represents an HTTP response and contains various response details.
+  class Response
+
+    # Range of HTTP response codes considered to be successful.
+    SuccessfulResponseCodes = 200..299
+
+    # Initializer expects an HTTP response +code+, +headers+ and +body+.
+    def initialize(code, headers, body)
+      self.code = code.to_i
+      self.headers = Rack::Utils::HeaderHash.new(headers)
+      self.raw_body = body
+    end
+
+    attr_accessor :code, :headers, :raw_body, :attachments
+
+    # Returns whether the HTTP response is considered successful.
+    def error?
+      !SuccessfulResponseCodes.include? code.to_i
+    end
+
+    # Returns whether the HTTP response is a multipart response.
+    def multipart?
+      !!(headers["Content-Type"] =~ /^multipart/i)
+    end
+
+    # Returns any DIME attachments.
+    def attachments
+      decode_body unless @body
+      @attachments ||= []
+    end
+
+    # Returns the HTTP response body.
+    def body
+      decode_body unless @body
+      @body
+    end
+
+    attr_writer :body
+
+  private
+
+    def decode_body
+      return @body = "" if !raw_body || raw_body.empty?
+      
+      body = gzipped_response? ? decoded_gzip_body : raw_body
+      @body = dime_response? ? decoded_dime_body(body) : body
+    end
+
+    # Returns whether the response is gzipped.
+    def gzipped_response?
+      headers["Content-Encoding"] == "gzip" || raw_body[0..1] == "\x1f\x8b"
+    end
+
+    # Returns whether this is a DIME response.
+    def dime_response?
+      headers["Content-Type"] == "application/dime"
+    end
+
+    # Returns the gzip decoded response body.
+    def decoded_gzip_body
+      gzip = Zlib::GzipReader.new StringIO.new(raw_body)
+      raise ArgumentError.new "couldn't create gzip reader" unless gzip
+      gzip.read
+    ensure
+      gzip.close if gzip
+    end
+
+    # Returns the DIME decoded response body.
+    def decoded_dime_body(body = nil)
+      dime = Dime.new(body || raw_body)
+      self.attachments = dime.binary_records
+      dime.xml_records.first.data
+    end
+
+  end
+end

data/lib/cs-httpi/version.rb

@@ -0,0 +1,5 @@
+module HTTPI
+
+  VERSION = "0.9.5.1"
+
+end

data/nbproject/private/private.properties

@@ -0,0 +1,2 @@
+file.reference.cs-httpi-lib=/home/tino/work/github/cs-httpi/lib
+file.reference.cs-httpi-spec=/home/tino/work/github/cs-httpi/spec

data/nbproject/project.properties

@@ -0,0 +1,7 @@
+file.reference.cs-httpi-lib=lib
+file.reference.cs-httpi-spec=spec
+main.file=
+platform.active=Ruby
+source.encoding=UTF-8
+src.dir=${file.reference.cs-httpi-lib}
+test.src.dir=${file.reference.cs-httpi-spec}

data/nbproject/project.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.ruby.rubyproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
+            <name>cs-httpi</name>
+            <source-roots>
+                <root id="src.dir"/>
+            </source-roots>
+            <test-roots>
+                <root id="test.src.dir"/>
+            </test-roots>
+        </data>
+    </configuration>
+</project>

data/spec/cs-httpi/adapter/curb_spec.rb

@@ -0,0 +1,232 @@
+require "spec_helper"
+require "cs-httpi/adapter/curb"
+require "cs-httpi/request"
+
+# curb does not run on jruby
+unless RUBY_PLATFORM =~ /java/
+  require "curb"
+
+  describe HTTPI::Adapter::Curb do
+    let(:adapter) { HTTPI::Adapter::Curb.new }
+    let(:curb) { Curl::Easy.any_instance }
+
+    describe "#get" do
+      before do
+        curb.expects(:http_get)
+        curb.expects(:response_code).returns(200)
+        curb.expects(:header_str).returns("Accept-encoding: utf-8")
+        curb.expects(:body_str).returns(Fixture.xml)
+      end
+
+      it "returns a valid HTTPI::Response" do
+        adapter.get(basic_request).should match_response(:body => Fixture.xml)
+      end
+    end
+
+    describe "#post" do
+      before do
+        curb.expects(:http_post)
+        curb.expects(:response_code).returns(200)
+        curb.expects(:header_str).returns("Accept-encoding: utf-8")
+        curb.expects(:body_str).returns(Fixture.xml)
+      end
+
+      it "returns a valid HTTPI::Response" do
+        adapter.post(basic_request).should match_response(:body => Fixture.xml)
+      end
+    end
+
+    describe "#post" do
+      it "sends the body in the request" do
+        curb.expects(:http_post).with('xml=hi&name=123')
+        adapter.post(basic_request { |request| request.body = 'xml=hi&name=123' } )
+      end
+    end
+
+    describe "#head" do
+      before do
+        curb.expects(:http_head)
+        curb.expects(:response_code).returns(200)
+        curb.expects(:header_str).returns("Accept-encoding: utf-8")
+        curb.expects(:body_str).returns(Fixture.xml)
+      end
+
+      it "returns a valid HTTPI::Response" do
+        adapter.head(basic_request).should match_response(:body => Fixture.xml)
+      end
+    end
+
+    describe "#put" do
+      before do
+        curb.expects(:http_put)
+        curb.expects(:response_code).returns(200)
+        curb.expects(:header_str).returns("Accept-encoding: utf-8")
+        curb.expects(:body_str).returns(Fixture.xml)
+      end
+
+      it "returns a valid HTTPI::Response" do
+        adapter.put(basic_request).should match_response(:body => Fixture.xml)
+      end
+    end
+
+    describe "#put" do
+      it "sends the body in the request" do
+        curb.expects(:http_put).with('xml=hi&name=123')
+        adapter.put(basic_request { |request| request.body = 'xml=hi&name=123' } )
+      end
+    end
+
+    describe "#delete" do
+      before do
+        curb.expects(:http_delete)
+        curb.expects(:response_code).returns(200)
+        curb.expects(:header_str).returns("Accept-encoding: utf-8")
+        curb.expects(:body_str).returns("")
+      end
+
+      it "returns a valid HTTPI::Response" do
+        adapter.delete(basic_request).should match_response(:body => "")
+      end
+    end
+
+    describe "settings:" do
+      before { curb.stubs(:http_get) }
+
+      describe "url" do
+        it "always sets the request url" do
+          curb.expects(:url=).with(basic_request.url.to_s)
+          adapter.get(basic_request)
+        end
+      end
+
+      describe "proxy_url" do
+        it "is not set unless it's specified" do
+          curb.expects(:proxy_url=).never
+          adapter.get(basic_request)
+        end
+
+        it "is set if specified" do
+          request = basic_request { |request| request.proxy = "http://proxy.example.com" }
+
+          curb.expects(:proxy_url=).with(request.proxy.to_s)
+          adapter.get(request)
+        end
+      end
+
+      describe "timeout" do
+        it "is not set unless it's specified" do
+          curb.expects(:timeout=).never
+          adapter.get(basic_request)
+        end
+
+        it "is set if specified" do
+          request = basic_request { |request| request.read_timeout = 30 }
+
+          curb.expects(:timeout=).with(30)
+          adapter.get(request)
+        end
+      end
+
+      describe "connect_timeout" do
+        it "is not set unless it's specified" do
+          curb.expects(:connect_timeout=).never
+          adapter.get(basic_request)
+        end
+
+        it "is set if specified" do
+          request = basic_request { |request| request.open_timeout = 30 }
+
+          curb.expects(:connect_timeout=).with(30)
+          adapter.get(request)
+        end
+      end
+
+      describe "headers" do
+        it "is always set" do
+          curb.expects(:headers=).with({})
+          adapter.get(basic_request)
+        end
+      end
+
+      describe "verbose" do
+        it "is always set to false" do
+          curb.expects(:verbose=).with(false)
+          adapter.get(basic_request)
+        end
+      end
+
+      describe "http_auth_types" do
+        it "is set to :basic for HTTP basic auth" do
+          request = basic_request { |request| request.auth.basic "username", "password" }
+
+          curb.expects(:http_auth_types=).with(:basic)
+          adapter.get(request)
+        end
+
+        it "is set to :digest for HTTP digest auth" do
+          request = basic_request { |request| request.auth.digest "username", "password" }
+
+          curb.expects(:http_auth_types=).with(:digest)
+          adapter.get(request)
+        end
+      end
+
+      describe "username and password" do
+        it "is set for HTTP basic auth" do
+          request = basic_request { |request| request.auth.basic "username", "password" }
+
+          curb.expects(:username=).with("username")
+          curb.expects(:password=).with("password")
+          adapter.get(request)
+        end
+
+        it "is set for HTTP digest auth" do
+          request = basic_request { |request| request.auth.digest "username", "password" }
+
+          curb.expects(:username=).with("username")
+          curb.expects(:password=).with("password")
+          adapter.get(request)
+        end
+      end
+
+      context "(for SSL client auth)" do
+        let(:ssl_auth_request) do
+          basic_request do |request|
+            request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
+            request.auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
+          end
+        end
+
+        it "cert_key, cert and ssl_verify_peer should be set" do
+          curb.expects(:cert_key=).with(ssl_auth_request.auth.ssl.cert_key_file)
+          curb.expects(:cert=).with(ssl_auth_request.auth.ssl.cert_file)
+          curb.expects(:ssl_verify_peer=).with(true)
+          curb.expects(:certtype=).with(ssl_auth_request.auth.ssl.cert_type.to_s.upcase)
+
+          adapter.get(ssl_auth_request)
+        end
+
+        it "sets the cert_type to DER if specified" do
+          ssl_auth_request.auth.ssl.cert_type = :der
+          curb.expects(:certtype=).with(:der.to_s.upcase)
+
+          adapter.get(ssl_auth_request)
+        end
+
+        it "sets the cacert if specified" do
+          ssl_auth_request.auth.ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
+          curb.expects(:cacert=).with(ssl_auth_request.auth.ssl.ca_cert_file)
+
+          adapter.get(ssl_auth_request)
+        end
+      end
+    end
+
+    def basic_request
+      request = HTTPI::Request.new :url => "http://example.com"
+      yield request if block_given?
+      request
+    end
+
+  end
+end