hhry-typhoeus 0.4.0

data/lib/typhoeus/easy.rb

@@ -0,0 +1,115 @@
+require 'typhoeus/easy/ffi_helper'
+require 'typhoeus/easy/options'
+require 'typhoeus/easy/ssl'
+require 'typhoeus/easy/auth'
+require 'typhoeus/easy/proxy'
+require 'typhoeus/easy/callbacks'
+require 'typhoeus/easy/infos'
+
+module Typhoeus
+  class Easy
+    include Typhoeus::EasyFu::FFIHelper
+    include Typhoeus::EasyFu::Options
+    include Typhoeus::EasyFu::SSL
+    include Typhoeus::EasyFu::Auth
+    include Typhoeus::EasyFu::Proxy
+    include Typhoeus::EasyFu::Callbacks
+    include Typhoeus::EasyFu::Infos
+
+    OPTION_VALUES = Curl::Option.to_hash.dup
+    Curl::Option.to_hash.each {|key, value| OPTION_VALUES["CURLOPT_#{key.to_s.upcase}".to_sym] = value }
+    INFO_VALUES = Curl::Info.to_hash.dup
+    Curl::Info.to_hash.each {|key, value| INFO_VALUES["CURLINFO_#{key.to_s.upcase}".to_sym] = value }
+    AUTH_TYPES = Curl::Auth.to_hash.dup
+    Curl::Auth.to_hash.each {|key, value| AUTH_TYPES["CURLAUTH_#{key.to_s.upcase}".to_sym] = value }
+    PROXY_TYPES = Curl::Proxy.to_hash.dup
+    Curl::Proxy.to_hash.each {|key, value| PROXY_TYPES["CURLPROXY_#{key.to_s.upcase}".to_sym] = value }
+    SSL_VERSIONS = Curl::SSLVersion.to_hash.dup
+    Curl::SSLVersion.to_hash.each {|key, value| SSL_VERSIONS["CURL_SSLVERSION_#{key.to_s.upcase}".to_sym] = value }
+
+    attr_reader :url, :header_list
+    attr_accessor :start_time
+
+    def initialize
+      Curl.init
+      reset(true)
+      ObjectSpace.define_finalizer(self, self.class.finalizer(self))
+    end
+
+    def method
+      @method ||= :get
+    end
+
+    def headers
+      @header ||= {}
+    end
+
+    def response_body
+      @response_body ||= ""
+    end
+
+    def response_header
+      @response_header ||= ""
+    end
+
+    def headers=(hash)
+      @headers = hash
+    end
+
+    def params
+      @form.nil? ? {} : @form.params
+    end
+
+    def params=(params)
+      @form = Typhoeus::Form.new(params)
+
+      if method == :post
+        @form.process!
+        if @form.multipart?
+          set_option(:httppost, @form)
+        else
+          self.post_data = @form.to_s
+        end
+      else
+        self.url = "#{url}?#{@form.to_s}"
+      end
+    end
+
+    def perform
+      set_headers()
+      @curl_return_code = Curl.easy_perform(handle)
+      resp_code = response_code()
+      if resp_code >= 200 && resp_code <= 299
+        success
+      else
+        failure
+      end
+      resp_code
+    end
+
+    def reset(fresh = nil)
+      unless fresh
+        @response_code = 0
+        @response_header = ""
+        @response_body = ""
+        @request_body = ""
+
+        if @header_list
+          Curl.slist_free_all(@header_list)
+          @header_list = nil
+        end
+
+        Curl.easy_reset(handle)
+      end
+
+      self.write_function = body_write_callback
+      self.header_function = header_write_callback
+      self.encoding = ''
+      self.ssl_version = :default
+    end
+
+    def curl_return_code=(code)
+      @curl_return_code = (code.class == Symbol ? code : Curl::EasyCode[code])
+    end
+  end
+end

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,86 @@
+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 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
+