ethon 0.0.1

data/lib/ethon/easies/util.rb

@@ -0,0 +1,41 @@
+module Ethon
+  module Easies # :nodoc:
+
+    # This module contains small helpers.
+    module Util
+
+      # Return query pairs from hash.
+      def build_query_pairs_from_hash(hash)
+        pairs = []
+        recursive = Proc.new do |h, prefix|
+          h.each_pair do |k,v|
+            key = prefix == '' ? k : "#{prefix}[#{k}]"
+            case v
+            when Hash
+              recursive.call(v, key)
+            when Array
+              v.each { |x| pairs << [key, x]  }
+            when File, Tempfile
+              pairs << [key, file_info(v)]
+            else
+              pairs << [key, v]
+            end
+          end
+        end
+        recursive.call(hash, '')
+        pairs
+      end
+
+      # Return file info for a file.
+      def file_info(file)
+        filename = File.basename(file.path)
+        types = MIME::Types.type_for(filename)
+        [
+          filename,
+          types.empty? ? 'application/octet-stream' : types[0].to_s,
+          File.expand_path(file.path)
+        ]
+      end
+    end
+  end
+end

data/lib/ethon/easy.rb

@@ -0,0 +1,104 @@
+require 'ethon/easies/informations'
+require 'ethon/easies/callbacks'
+require 'ethon/easies/options'
+require 'ethon/easies/header'
+require 'ethon/easies/util'
+require 'ethon/easies/params'
+require 'ethon/easies/form'
+require 'ethon/easies/http'
+require 'ethon/easies/operations'
+require 'ethon/easies/response_callbacks'
+
+module Ethon
+
+  # This is the class representing the libcurl easy interface
+  # See http://curl.haxx.se/libcurl/c/libcurl-easy.html for more informations.
+  class Easy
+    include Ethon::Easies::Informations
+    include Ethon::Easies::Callbacks
+    include Ethon::Easies::Options
+    include Ethon::Easies::Header
+    include Ethon::Easies::Http
+    include Ethon::Easies::Operations
+    include Ethon::Easies::ResponseCallbacks
+
+    attr_reader :response_body, :response_header
+    attr_accessor :return_code
+
+    class << self
+
+      # Free libcurl representation from an easy handle.
+      #
+      # @example Free easy handle.
+      #   Easy.finalizer(easy)
+      #
+      # @param [ Easy ] easy The easy to free.
+      def finalizer(easy)
+        proc {
+          Curl.slist_free_all(easy.header_list) if easy.header_list
+          Curl.easy_cleanup(easy.handle)
+        }
+      end
+    end
+
+    # Initialize a new Easy.
+    # It initializes curl, if not already done and applies the provided options.
+    #
+    # @example Create a new Easy.
+    #   Easy.new(:url => "www.google.de")
+    #
+    # @param [ Hash ] options The options to set.
+    #
+    # @return [ Easy ] A new Easy.
+    def initialize(options = {})
+      Curl.init
+      ObjectSpace.define_finalizer(self, self.class.finalizer(self))
+      set_attributes(options)
+    end
+
+    # Set given options.
+    #
+    # @example Set options.
+    #   easy.set_attributes(options)
+    #
+    # @param [ Hash ] options The options.
+    def set_attributes(options)
+      options.each_pair do |key, value|
+        method("#{key}=").call(value) if respond_to?("#{key}=")
+      end
+    end
+
+    # Reset easy. This means resetting all options and instance variables.
+    # Also the easy handle is resetted.
+    #
+    # @example Reset.
+    #   easy.reset
+    def reset
+      (instance_variables - [:@handle, :@header_list]).each do |ivar|
+        instance_variable_set(ivar, nil)
+      end
+      Curl.easy_reset(handle)
+    end
+
+    # Returns a  pointer to the curl easy handle.
+    #
+    # @example Return the handle.
+    #   easy.handle
+    #
+    # @return [ FFI::Pointer ] A pointer to the curl easy handle.
+    def handle
+      @handle ||= Curl.easy_init
+    end
+
+    def to_hash
+      hash = {}
+      hash[:return_code] = return_code
+      hash[:response_header] = response_header
+      hash[:response_body] = response_body
+      Easies::Informations::AVAILABLE_INFORMATIONS.keys.each do |info|
+        hash[info] = method(info).call
+      end
+      hash
+    end
+  end
+end

data/lib/ethon/errors.rb

@@ -0,0 +1,13 @@
+require 'ethon/errors/ethon_error'
+require 'ethon/errors/multi_timeout'
+require 'ethon/errors/multi_fdset'
+require 'ethon/errors/multi_add'
+require 'ethon/errors/multi_remove'
+require 'ethon/errors/select'
+
+module Ethon
+
+  # This namespace contains all errors raised by ethon.
+  module Errors
+  end
+end

data/lib/ethon/errors/ethon_error.rb

@@ -0,0 +1,8 @@
+module Ethon
+  module Errors
+
+    # Default Ethon error class for all custom errors.
+    class EthonError < StandardError
+    end
+  end
+end

data/lib/ethon/errors/multi_add.rb

@@ -0,0 +1,12 @@
+module Ethon
+  module Errors
+
+    # Raises when multi_add_handle failed.
+    class MultiAdd < EthonError
+      def initialize(code, easy)
+        super("An error occured adding the easy handle: #{easy} to the multi: #{code}")
+        # "an error occured getting the fdset: #{code}: #{Curl.multi_strerror(code)}"
+      end
+    end
+  end
+end

data/lib/ethon/errors/multi_fdset.rb

@@ -0,0 +1,12 @@
+module Ethon
+  module Errors
+
+    # Raises when multi_fdset failed.
+    class MultiFdset < EthonError
+      def initialize(code)
+        super("An error occured getting the fdset: #{code}")
+        # "an error occured getting the fdset: #{code}: #{Curl.multi_strerror(code)}"
+      end
+    end
+  end
+end

data/lib/ethon/errors/multi_remove.rb

@@ -0,0 +1,11 @@
+module Ethon
+  module Errors
+
+    # Raises when multi_remove_handle failed.
+    class MultiRemove < EthonError
+      def initialize(code, easy)
+        super("An error occured removing the easy handle: #{easy} from the multi: #{code}")
+      end
+    end
+  end
+end

data/lib/ethon/errors/multi_timeout.rb

@@ -0,0 +1,12 @@
+module Ethon
+  module Errors
+
+    # Raised when multi_timeout failed.
+    class MultiTimeout < EthonError
+      def initialize(code)
+        super("An error occured getting the timeout: #{code}")
+        # "An error occured getting the timeout: #{code}: #{Curl.multi_strerror(code)}"
+      end
+    end
+  end
+end

data/lib/ethon/errors/select.rb

@@ -0,0 +1,12 @@
+module Ethon
+  module Errors
+
+    # Raised when select failed.
+    class Select < EthonError
+      def initialize(errno)
+        super("An error occured on select: #{errno}")
+      end
+    end
+  end
+end
+

data/lib/ethon/extensions.rb

@@ -0,0 +1 @@
+require 'ethon/extensions/string.rb' unless ''.respond_to?(:byteslice)

data/lib/ethon/extensions/string.rb

@@ -0,0 +1,11 @@
+module Ethon
+  module Extensions
+    module String
+      def byteslice(*args)
+        self[*args]
+      end
+    end
+  end
+end
+
+::String.__send__(:include, Ethon::Extensions::String)

data/lib/ethon/multi.rb

@@ -0,0 +1,47 @@
+require 'ethon/multies/stack'
+require 'ethon/multies/operations'
+
+module Ethon
+
+  # This class represents libcurl multi.
+  class Multi
+    include Ethon::Multies::Stack
+    include Ethon::Multies::Operations
+
+    class << self
+
+      # Frees the libcurl multi handle.
+      #
+      # @example Free multi.
+      #   Multi.finalizer(multi)
+      #
+      # @param [ Multi ] multi The multi to free.
+      def finalizer(multi)
+        proc {
+          Curl.multi_cleanup(multi.handle)
+        }
+      end
+    end
+
+    # Create a new multi. Initialize curl in case
+    # it didn't happen before.
+    #
+    # @return [ Multi ] The new multi.
+    def initialize
+      Curl.init
+      ObjectSpace.define_finalizer(self, self.class.finalizer(self))
+      init_vars
+    end
+
+    # Return the multi handle. Inititialize multi handle,
+    # in case it didn't happened already.
+    #
+    # @example Return multi handle.
+    #   multi.handle
+    #
+    # @return [ ::FFI::Pointer ] The multi handle.
+    def handle
+      @handle ||= Curl.multi_init
+    end
+  end
+end

data/lib/ethon/multies/operations.rb

@@ -0,0 +1,132 @@
+module Ethon
+  module Multies # :nodoc
+
+    # This module contains logic to run a multi.
+    module Operations
+
+      # Initialize variables.
+      #
+      # @example Initialize variables.
+      #   multi.init_vars
+      def init_vars
+        @timeout = ::FFI::MemoryPointer.new(:long)
+        @timeval = Curl::Timeval.new
+        @fd_read = Curl::FDSet.new
+        @fd_write = Curl::FDSet.new
+        @fd_excep = Curl::FDSet.new
+        @max_fd = ::FFI::MemoryPointer.new(:int)
+      end
+
+      # Return wether the multi still requests or not.
+      #
+      # @example Return if ongoing.
+      #   multi.ongoing?
+      #
+      # @return [ Boolean ] True if ongoing, else false.
+      def ongoing?
+        easy_handles.size > 0 || (!defined?(@running_count) || running_count > 0)
+      end
+
+      # Perform multi.
+      #
+      # @example Perform multi.
+      #   multi.perform
+      def perform
+        while ongoing?
+          run
+          timeout = get_timeout
+          next if timeout == 0
+          reset_fds
+          set_fds(timeout)
+        end
+      end
+
+      # Get timeout.
+      #
+      # @example Get timeout.
+      #   multi.get_timeout
+      def get_timeout
+        code = Curl.multi_timeout(handle, @timeout)
+        raise Errors::MultiTimeout.new(code) unless code == :ok
+        timeout = @timeout.read_long
+        timeout = 1 if timeout < 0
+        timeout
+      end
+
+      # Reset file describtors.
+      #
+      # @example Reset fds.
+      #   multi.reset_fds
+      def reset_fds
+        @fd_read.clear
+        @fd_write.clear
+        @fd_excep.clear
+      end
+
+      # Set fds.
+      #
+      # @example Set fds.
+      #   multi.set_fds
+      def set_fds(timeout)
+        code = Curl.multi_fdset(handle, @fd_read, @fd_write, @fd_excep, @max_fd)
+        raise Errors::MultiFdset.new(code) unless code == :ok
+        max_fd = @max_fd.read_int
+        if max_fd == -1
+          sleep(0.001)
+        else
+          @timeval[:sec] = timeout / 1000
+          @timeval[:usec] = (timeout * 1000) % 1000000
+          code = Curl.select(max_fd + 1, @fd_read, @fd_write, @fd_excep, @timeval)
+          raise Errors::Select.new(::FFI.errno) if code < 0
+        end
+      end
+
+      # Check.
+      #
+      # @example Check.
+      #   multi.check
+      def check
+        msgs_left = ::FFI::MemoryPointer.new(:int)
+        while true
+          msg = Curl.multi_info_read(handle, msgs_left)
+          break if msg.null?
+          next if msg[:code] != :done
+          easy = easy_handles.find{ |e| e.handle == msg[:easy_handle] }
+          easy.return_code = msg[:data][:code]
+          delete(easy)
+          easy.complete
+        end
+      end
+
+      # Run.
+      #
+      # @example Run
+      #   multi.run
+      def run
+        begin code = trigger end while code == :call_multi_perform
+        check
+      end
+
+      # Trigger.
+      #
+      # @example Trigger.
+      #   multi.trigger
+      def trigger
+        running_count = FFI::MemoryPointer.new(:int)
+        code = Curl.multi_perform(handle, running_count)
+        @running_count = running_count.read_int
+        code
+      end
+
+      # Return number of running requests.
+      #
+      # @example Return count.
+      #   multi.running_count
+      #
+      # @return [ Integer ] Number running requests.
+      def running_count
+        @running_count ||= nil
+      end
+    end
+  end
+end

data/lib/ethon/multies/stack.rb

@@ -0,0 +1,43 @@
+module Ethon
+  module Multies
+
+    # This module provides the multi stack behaviour.
+    module Stack
+
+      # Return easy handles.
+      #
+      # @example Return easy handles.
+      #   multi.easy_handles
+      #
+      # @return [ Array ] The easy handles.
+      def easy_handles
+        @easy_handles ||= []
+      end
+
+      # Add an easy to the stack.
+      #
+      # @example Add easy.
+      #   multi.add(easy)
+      #
+      # @param [ Easy ] easy The easy to add.
+      def add(easy)
+        return nil if easy_handles.include?(easy)
+        code = Curl.multi_add_handle(handle, easy.handle)
+        raise Errors::MultiAdd.new(code, easy) unless code == :ok
+        easy_handles << easy
+      end
+
+      # Delete an easy from stack.
+      #
+      # @example Delete easy from stack.
+      #
+      # @param [ Easy ] easy The easy to delete.
+      def delete(easy)
+        if easy_handles.delete(easy)
+          code = Curl.multi_remove_handle(handle, easy.handle)
+          raise Errors::MultiRemove.new(code, handle) unless code == :ok
+        end
+      end
+    end
+  end
+end