typhoeus 0.3.3 → 0.4.0

data/lib/typhoeus/easy/auth.rb

@@ -0,0 +1,14 @@
+module Typhoeus
+  module EasyFu
+    module Auth
+      def auth=(authinfo)
+        set_option(:userpwd, auth_credentials(authinfo))
+        set_option(:httpauth, Typhoeus::Easy::AUTH_TYPES[authinfo[:method]]) if authinfo[:method]
+      end
+
+      def auth_credentials(authinfo)
+        "#{authinfo[:username]}:#{authinfo[:password]}"
+      end
+    end
+  end
+end

data/lib/typhoeus/easy/callbacks.rb

@@ -0,0 +1,33 @@
+module Typhoeus
+  module EasyFu
+    module Callbacks
+      # gets called when finished and response code is not 2xx,
+      # or curl returns an error code.
+      def success
+        @success.call(self) if @success
+      end
+
+      def on_success(&block)
+        @success = block
+      end
+
+      def on_success=(block)
+        @success = block
+      end
+
+      # gets called when finished and response code is 300-599
+      # or curl returns an error code
+      def failure
+        @failure.call(self) if @failure
+      end
+
+      def on_failure(&block)
+        @failure = block
+      end
+
+      def on_failure=(block)
+        @failure = block
+      end
+    end
+  end
+end

data/lib/typhoeus/easy/ffi_helper.rb

@@ -0,0 +1,61 @@
+module Typhoeus
+  module EasyFu
+    module FFIHelper
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def finalizer(easy)
+          proc {
+            Curl.slist_free_all(easy.header_list) if easy.header_list
+            Curl.easy_cleanup(easy.handle)
+          }
+        end
+      end
+
+      def handle
+        @handle ||= Curl.easy_init
+      end
+
+      def body_write_callback
+        @body_write_callback ||= proc {|stream, size, num, object|
+          response_body << stream.read_string(size * num)
+          size * num
+        }
+      end
+
+      def header_write_callback
+        @header_write_callback ||= proc {|stream, size, num, object|
+          response_header << stream.read_string(size * num)
+          size * num
+        }
+      end
+
+      def read_callback
+        @read_callback ||= proc {|stream, size, num, object|
+          size = size * num
+          left = Utils.bytesize(@request_body) - @request_body_read
+          size = left if size > left
+          if size > 0
+            stream.write_string(Utils.byteslice(@request_body, @request_body_read, size), size)
+            @request_body_read += size
+          end
+          size
+        }
+      end
+
+      def string_ptr
+        @string_ptr ||= ::FFI::MemoryPointer.new(:pointer)
+      end
+
+      def long_ptr
+        @long_ptr ||= ::FFI::MemoryPointer.new(:long)
+      end
+
+      def double_ptr
+        @double_ptr ||= ::FFI::MemoryPointer.new(:double)
+      end
+    end
+  end
+end

data/lib/typhoeus/easy/infos.rb

@@ -0,0 +1,90 @@
+module Typhoeus
+  module EasyFu
+    module Infos
+      def get_info_string(option)
+        if Curl.easy_getinfo(@handle, option, string_ptr) == :ok
+          string_ptr.read_pointer.read_string
+        else nil
+        end
+      end
+
+      def get_info_long(option)
+        if Curl.easy_getinfo(@handle, option, long_ptr) == :ok
+          long_ptr.read_long
+        else nil
+        end
+      end
+
+      def get_info_double(option)
+        if Curl.easy_getinfo(@handle, option, double_ptr) == :ok
+          double_ptr.read_double
+        else nil
+        end
+      end
+
+      def auth_methods
+        get_info_long(:httpauth_avail)
+      end
+
+      def total_time_taken
+        get_info_double(:total_time)
+      end
+
+      def start_transfer_time
+        get_info_double(:starttransfer_time)
+      end
+
+      def app_connect_time
+        get_info_double(:appconnect_time)
+      end
+
+      def pretransfer_time
+        get_info_double(:pretransfer_time)
+      end
+
+      def connect_time
+        get_info_double(:connect_time)
+      end
+
+      def name_lookup_time
+        get_info_double(:namelookup_time)
+      end
+
+      def effective_url
+        get_info_string(:effective_url)
+      end
+
+      def primary_ip
+        get_info_string(:primary_ip)
+      end
+
+      def response_code
+        get_info_long(:response_code)
+      end
+
+      def timed_out?
+        @curl_return_code == :operation_timedout
+      end
+
+      def redirect_count
+        get_info_long(:redirect_count)
+      end
+
+      def curl_return_code
+        Curl::EasyCode[@curl_return_code]
+      end
+
+      def curl_error_message(code = @curl_return_code)
+        code ? Curl.easy_strerror(code) : nil
+      end
+
+      def curl_version
+        Curl.version
+      end
+
+      def supports_zlib?
+        !!(curl_version.match(/zlib/))
+      end
+    end
+  end
+end

data/lib/typhoeus/easy/options.rb

@@ -0,0 +1,115 @@
+module Typhoeus
+  module EasyFu
+    module Options
+      def write_function=(callback)
+        set_option(:writefunction, body_write_callback)
+      end
+
+      def header_function=(callback)
+        set_option(:headerfunction, header_write_callback)
+      end
+
+      def encoding=(encoding)
+        # Enable encoding/compression support
+        set_option(:encoding, encoding)
+      end
+
+      def interface=(interface)
+        @interface = interface
+        set_option(:interface, interface)
+      end
+
+      def verbose=(boolean)
+        set_option(:verbose, !!boolean ? 1 : 0)
+      end
+
+      def follow_location=(boolean)
+        if boolean
+          set_option(:followlocation, 1)
+        else
+          set_option(:followlocation, 0)
+        end
+      end
+
+      def max_redirects=(redirects)
+        set_option(:maxredirs, redirects)
+      end
+
+      def connect_timeout=(milliseconds)
+        @connect_timeout = milliseconds
+        set_option(:nosignal, 1)
+        set_option(:connecttimeout_ms, milliseconds)
+      end
+
+      def timeout=(milliseconds)
+        @timeout = milliseconds
+        set_option(:nosignal, 1)
+        set_option(:timeout_ms, milliseconds)
+      end
+
+      def request_body=(request_body)
+        @request_body = request_body
+        if method == :put
+          @request_body_read = 0
+          set_option(:infilesize, Utils.bytesize(@request_body))
+          set_option(:readfunction, read_callback)
+        else
+          self.post_data = request_body
+        end
+      end
+
+      def user_agent=(user_agent)
+        set_option(:useragent, user_agent)
+      end
+
+      def url=(url)
+        @url = url
+        set_option(:url, url)
+      end
+
+      def method=(method)
+        @method = method
+        if method == :get
+          set_option(:httpget, 1)
+        elsif method == :post
+          set_option(:httppost, 1)
+          self.post_data = ""
+        elsif method == :put
+          set_option(:upload, 1)
+          self.request_body = @request_body.to_s
+        elsif method == :head
+          set_option(:nobody, 1)
+        else
+          set_option(:customrequest, method.to_s.upcase)
+        end
+      end
+
+      def post_data=(data)
+        @post_data_set = true
+        set_option(:postfieldsize, Utils.bytesize(data))
+        set_option(:copypostfields, data)
+      end
+
+      def set_option(option, value)
+        case value
+        when String
+          Curl.easy_setopt_string(handle, option, value.to_s)
+        when Integer
+          Curl.easy_setopt_long(handle, option, value)
+        when Proc, ::FFI::Function
+          Curl.easy_setopt_callback(handle, option, value)
+        when Typhoeus::Form
+          Curl.easy_setopt(handle, option, value.first.read_pointer)
+        else
+          Curl.easy_setopt(handle, option, value) if value
+        end
+      end
+
+      def set_headers
+        @header_list = nil
+        headers.each {|key, value| @header_list = Curl.slist_append(@header_list, "#{key}: #{value}") }
+        set_option(:httpheader, @header_list) unless headers.empty?
+      end
+    end
+  end
+end

data/lib/typhoeus/easy/proxy.rb

@@ -0,0 +1,20 @@
+module Typhoeus
+  module EasyFu
+    module Proxy
+      def proxy=(proxy)
+        set_option(:proxy, proxy[:server])
+        set_option(:proxytype, Typhoeus::Easy::PROXY_TYPES[proxy[:type]]) if proxy[:type]
+      end
+
+      def proxy_auth=(authinfo)
+        set_option(:proxyuserpwd, proxy_credentials(authinfo))
+        set_option(:proxyauth, Typhoeus::Easy::PROXY_TYPES[proxy[:type]]) if authinfo[:method]
+      end
+
+      def proxy_credentials(authinfo)
+        "#{authinfo[:username]}:#{authinfo[:password]}"
+      end
+    end
+  end
+end
+

data/lib/typhoeus/easy/ssl.rb

@@ -0,0 +1,82 @@
+module Typhoeus
+  module EasyFu
+    module SSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def valid_ssl_version(version)
+          Typhoeus::Easy::SSL_VERSIONS.key?(version.to_sym)
+        end
+      end
+
+      def ssl_version
+        @ssl_version
+      end
+
+      def ssl_version=(version)
+        raise "Invalid SSL version: '#{version}' supplied! Please supply one as listed in Typhoeus::Easy::SSL_VERSIONS" unless self.class.valid_ssl_version(version)
+        @ssl_version = version
+
+        set_option(:sslversion, Typhoeus::Easy::SSL_VERSIONS[version])
+      end
+
+      def disable_ssl_peer_verification
+        set_option(:verifypeer, 0)
+      end
+
+      def disable_ssl_host_verification
+        set_option(:verifyhost, 0)
+      end
+
+      # Set SSL certificate
+      # " The string should be the file name of your certificate. "
+      # The default format is "PEM" and can be changed with ssl_cert_type=
+      def ssl_cert=(cert)
+        set_option(:sslcert, cert)
+      end
+
+      # Set SSL certificate type
+      # " The string should be the format of your certificate. Supported formats are "PEM" and "DER" "
+      def ssl_cert_type=(cert_type)
+        raise "Invalid ssl cert type : '#{cert_type}'..." if cert_type and !%w(PEM DER p12).include?(cert_type)
+        set_option(:sslcerttype, cert_type)
+      end
+
+      # Set SSL Key file
+      # " The string should be the file name of your private key. "
+      # The default format is "PEM" and can be changed with ssl_key_type=
+      #
+      def ssl_key=(key)
+        set_option(:sslkey, key)
+      end
+
+      # Set SSL Key type
+      # " The string should be the format of your private key. Supported formats are "PEM", "DER" and "ENG". "
+      #
+      def ssl_key_type=(key_type)
+        raise "Invalid ssl key type : '#{key_type}'..." if key_type and !%w(PEM DER ENG).include?(key_type)
+        set_option(:sslkeytype, key_type)
+      end
+
+      def ssl_key_password=(key_password)
+        set_option(:keypasswd, key_password)
+      end
+
+      # Set SSL CACERT
+      # " File holding one or more certificates to verify the peer with. "
+      #
+      def ssl_cacert=(cacert)
+        set_option(:cainfo, cacert)
+      end
+
+      # Set CAPATH
+      # " directory holding multiple CA certificates to verify the peer with. The certificate directory must be prepared using the openssl c_rehash utility. "
+      #
+      def ssl_capath=(capath)
+        set_option(:capath, capath)
+      end
+    end
+  end
+end

data/lib/typhoeus/form.rb

@@ -3,16 +3,45 @@ require 'mime/types'
 module Typhoeus
   class Form
     attr_accessor :params
-    attr_reader :traversal
+    attr_reader :first, :traversal
 
     def initialize(params = {})
       @params = params
+      @first = ::FFI::MemoryPointer.new(:pointer)
+      @last = ::FFI::MemoryPointer.new(:pointer)
+
+      ObjectSpace.define_finalizer(self, self.class.finalizer(self))
+    end
+
+    def self.finalizer(form)
+      proc { Curl.formfree(form.first) }
     end
 
     def traversal
       @traversal ||= Typhoeus::Utils.traverse_params_hash(params)
     end
 
+    def formadd_param(name, contents)
+      Curl.formadd(@first, @last,
+        :form_option, :copyname, :pointer, name,
+        :form_option, :namelength, :long, Utils.bytesize(name),
+        :form_option, :copycontents, :pointer, contents,
+        :form_option, :contentslength, :long, Utils.bytesize(contents),
+        :form_option, :end)
+    end
+    private :formadd_param
+
+    def formadd_file(name, filename, contenttype, file)
+      Curl.formadd(@first, @last,
+        :form_option, :copyname, :pointer, name,
+        :form_option, :namelength, :long, Utils.bytesize(name),
+        :form_option, :file, :string, file,
+        :form_option, :filename, :string, filename,
+        :form_option, :contenttype, :string, contenttype,
+        :form_option, :end)
+    end
+    private :formadd_file
+
     def process!
       # add params
       traversal[:params].each { |p| formadd_param(p[0], p[1]) }