streamly_ffi 0.1.5

data/lib/streamly_ffi.rb

@@ -0,0 +1,122 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+# encoding: UTF-8
+require 'streamly_ffi/version'
+
+module StreamlyFFI
+  autoload :Request, "streamly_ffi/request"
+
+  class Error               < StandardError; end
+  class UnsupportedProtocol < StandardError; end
+  class URLFormatError      < StandardError; end
+  class HostResolutionError < StandardError; end
+  class ConnectionFailed    < StandardError; end
+  class PartialFileError    < StandardError; end
+  class TimeoutError        < StandardError; end
+  class TooManyRedirects    < StandardError; end
+
+  # A helper method to make HEAD requests a dead-simple one-liner
+  #
+  # Example:
+  #   Streamly.head("www.somehost.com/some_resource/1")
+  #
+  #   Streamly.head("www.somehost.com/some_resource/1") do |header_chunk|
+  #     # do something with _header_chunk_
+  #   end
+  #
+  # Parameters:
+  # +url+ should be a String, the url to request
+  # +headers+ should be a Hash and is optional
+  # 
+  # This method also accepts a block, which will stream the response headers in chunks to the caller
+  def self.head(url, headers=nil, &block)
+    opts = {:method => :head, :url => url, :headers => headers}
+    opts.merge!({:response_header_handler => block}) if block_given?
+    Request.execute(opts)
+  end
+
+  # A helper method to make HEAD requests a dead-simple one-liner
+  #
+  # Example:
+  #   Streamly.get("www.somehost.com/some_resource/1")
+  #
+  #   Streamly.get("www.somehost.com/some_resource/1") do |chunk|
+  #     # do something with _chunk_
+  #   end
+  #
+  # Parameters:
+  # +url+ should be a String, the url to request
+  # +headers+ should be a Hash and is optional
+  # 
+  # This method also accepts a block, which will stream the response body in chunks to the caller
+  def self.get(url, headers=nil, &block)
+    opts = {:method => :get, :url => url, :headers => headers}
+    opts.merge!({:response_body_handler => block}) if block_given?
+    Request.execute(opts)
+  end
+
+  # A helper method to make HEAD requests a dead-simple one-liner
+  #
+  # Example:
+  #   Streamly.post("www.somehost.com/some_resource", "asset[id]=2&asset[name]=bar")
+  #
+  #   Streamly.post("www.somehost.com/some_resource", "asset[id]=2&asset[name]=bar") do |chunk|
+  #     # do something with _chunk_
+  #   end
+  #
+  # Parameters:
+  # +url+ should be a String (the url to request) and is required
+  # +payload+ should be a String and is required
+  # +headers+ should be a Hash and is optional
+  # 
+  # This method also accepts a block, which will stream the response body in chunks to the caller
+  def self.post(url, payload, headers=nil, &block)
+    opts = {:method => :post, :url => url, :payload => payload, :headers => headers}
+    opts.merge!({:response_body_handler => block}) if block_given?
+    Request.execute(opts)
+  end
+
+  # A helper method to make HEAD requests a dead-simple one-liner
+  #
+  # Example:
+  #   Streamly.put("www.somehost.com/some_resource/1", "asset[name]=foo")
+  #
+  #   Streamly.put("www.somehost.com/some_resource/1", "asset[name]=foo") do |chunk|
+  #     # do something with _chunk_
+  #   end
+  #
+  # Parameters:
+  # +url+ should be a String (the url to request) and is required
+  # +payload+ should be a String and is required
+  # +headers+ should be a Hash and is optional
+  # 
+  # This method also accepts a block, which will stream the response body in chunks to the caller
+  def self.put(url, payload, headers=nil, &block)
+    opts = {:method => :put, :url => url, :payload => payload, :headers => headers}
+    opts.merge!({:response_body_handler => block}) if block_given?
+    Request.execute(opts)
+  end
+
+  # A helper method to make HEAD requests a dead-simple one-liner
+  #
+  # Example:
+  #   Streamly.delete("www.somehost.com/some_resource/1")
+  #
+  #   Streamly.delete("www.somehost.com/some_resource/1") do |chunk|
+  #     # do something with _chunk_
+  #   end
+  #
+  # Parameters:
+  # +url+ should be a String, the url to request
+  # +headers+ should be a Hash and is optional
+  # 
+  # This method also accepts a block, which will stream the response body in chunks to the caller
+  def self.delete(url, headers={}, &block)
+    opts = {:method => :delete, :url => url, :headers => headers}
+    opts.merge!({:response_body_handler => block}) if block_given?
+    Request.execute(opts)
+  end
+end
+
+# require "streamly/request"  # May need to do this? Not sure how autoload works with FFI yet

data/lib/streamly_ffi/request.rb

@@ -0,0 +1,163 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "curl_ffi"
+require "singleton"
+
+module StreamlyFFI
+  class Request
+    include Singleton
+
+    alias __method__ method
+
+    attr_reader :url, :method
+
+    # @TODO: Argumenting Checking + Error Handling
+    def initialize(options={})
+      url     = options[:url]
+      method  = options[:method]
+      
+      @response_body          = nil
+      @response_header        = nil
+      @custom_header_handler  = nil
+      @custom_write_handler   = nil
+
+      # url should be a string that doesn't suck
+      # method should be :post, :get, :put, :delete, :head
+      # options should contain any of the following keys:
+      #   :headers, :response_header_handler, :response_body_handler, :payload (required if method = :post / :put)
+
+      case method
+      when :get     then  connection.setopt :HTTPGET,        1
+      when :head    then  connection.setopt :NOBODY,         1
+      when :post    then  connection.setopt :POST,           1
+                          connection.setopt :POSTFIELDS,     options[:payload]
+                          connection.setopt :POSTFIELDSIZE,  options[:payload].size
+      when :put     then  connection.setopt :CUSTOMREQUEST,  "PUT"
+                          connection.setopt :POSTFIELDS,     options[:payload]
+                          connection.setopt :POSTFIELDSIZE,  options[:payload].size
+      when :delete  then  connection.setopt :CUSTOMREQUEST,  "DELETE"
+      # else I WILL CUT YOU
+      end
+
+      if options[:headers].is_a? Hash and options[:headers].size > 0
+        options[:headers].each_pair do |key_and_value|
+          request_headers = CurlFFI.slist_append(request_headers, key_and_value.join(": "))
+        end
+        connection.setopt :HTTPHEADER, request_headers
+      end
+
+      @custom_header_handler  = options[:response_header_handler] if options.has_key?(:response_header_handler)
+      @custom_write_handler   = options[:response_body_handler]   if options.has_key?(:response_body_handler)
+
+      default_header_handler
+      default_write_handler
+
+      
+      connection.setopt :ENCODING,        "identity, deflate, gzip" unless method == :head
+      connection.setopt :URL,             url
+
+      # Other common options (blame streamly guy)
+      connection.setopt :FOLLOWLOCATION,  1
+      connection.setopt :MAXREDIRS,       3
+      # @TODO: This should be an option
+      connection.setopt :SSL_VERIFYPEER,  0
+      connection.setopt :SSL_VERIFYHOST,  0
+
+      connection.setopt :ERRORBUFFER,     error_buffer
+
+      return self # I am a terrible hack. I should abandon the singleton
+    end
+
+    def connection
+      @connection ||= CurlFFI::Easy.new
+    end
+
+    def error_buffer
+      @error_buffer ||= FFI::MemoryPointer.new(:char, CurlFFI::ERROR_SIZE, :clear)
+    end
+    
+    def request_headers
+      @request_headers ||= FFI::MemoryPointer.from_string("")
+    end
+    
+    def response_body
+      @response_body ||= ""
+    end
+    
+    def response_header
+      @response_header ||= ""
+    end
+
+    def execute
+      status = connection.perform
+
+      # @TODO: Intelligent error stuff
+#      raise Streamly::Error if status 
+
+      CurlFFI.slist_free_all(@request_headers) if @request_headers
+
+      @connection.reset
+    end
+    
+    def self.execute(options={})
+      request = new(options)
+
+      request.execute
+
+      return nil if(options.has_key?(:response_header_handler) or options.has_key?(:response_body_handler))
+
+      resp  = if(options[:method] == :head && request.response_header.respond_to?(:to_str))
+                request.response_header
+              elsif(request.response_body.is_a?(String))
+                request.response_body
+              else
+                nil
+              end
+
+      return resp
+    end
+
+    def default_write_handler
+      connection.setopt(:WRITEFUNCTION, FFI::Function.new(:size_t, [:pointer, :size_t, :size_t,], &self.__method__(:write_callback)))
+    end
+
+    def default_header_handler
+      connection.setopt(:HEADERFUNCTION, FFI::Function.new(:size_t, [:pointer, :size_t, :size_t], &self.__method__(:header_callback)))
+    end
+
+    def write_callback(string_ptr, size, nmemb)
+      length = size * nmemb
+
+      if(@custom_write_handler)
+        @custom_write_handler.call(string_ptr.read_string(length))
+      else
+        response_body << string_ptr.read_string(length)
+      end
+
+      return length
+    end
+
+    def header_callback(string_ptr, size, nmemb)
+      length = size * nmemb
+
+      if(@custom_header_handler)
+        @custom_header_handler.call(string_ptr.read_string(length))
+      else
+        response_header << string_ptr.read_string(length)
+      end
+
+      return length
+    end
+
+  # streamly's .c internal methods:
+  # @TODO: header_handler
+  # @TODO: data_handler
+  # @TODO: each_http_header
+  # @TODO: select_error
+  # @TODO: rb_streamly_new
+  # @TODO: rb_streamly_init
+  # @TODO: nogvl_perform
+  # @TODO: rb_streamly_execute
+  end
+end

data/lib/streamly_ffi/version.rb

@@ -0,0 +1,3 @@
+module StreamlyFFI
+  VERSION = "0.1.5"
+end

data/spec/server.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'sinatra'
+
+get '/' do
+  "Hello, #{params[:name]}".strip
+end
+
+post '/' do
+  "Hello, #{params[:name]}".strip
+end
+
+put '/' do
+  "Hello, #{params[:name]}".strip
+end
+
+delete '/' do
+  "Hello, #{params[:name]}".strip
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'streamly_ffi'
+require 'rspec'

data/spec/streamly_ffi/request_spec.rb

@@ -0,0 +1,293 @@
+# encoding: UTF-8
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+describe StreamlyFFI::Request do
+
+  before(:all) do
+    @response = "Hello, brian".strip
+  end
+
+  describe "HEAD" do
+    describe "basic" do
+      it "should perform a basic request" do
+        resp = Streamly.head('localhost:4567')
+        resp.should_not be_nil
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.head('localhost:4567').encoding.should eql(Encoding.find('utf-8'))
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.head('localhost:4567').encoding.should eql(Encoding.default_internal)
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.head('localhost:4567').encoding.should eql(Encoding.default_internal)
+        end
+      end
+=end
+    end
+
+    describe "streaming" do
+      it "should perform a basic request and stream header chunks to the caller" do
+        streamed_response = ""
+        resp = Streamly.head('localhost:4567') do |chunk|
+          chunk.should_not be_empty
+          streamed_response << chunk
+        end
+        resp.should be_nil
+        streamed_response.should_not be_nil
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.head('localhost:4567') do |chunk|
+            chunk.encoding.should eql(Encoding.find('utf-8'))
+          end
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.head('localhost:4567') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.head('localhost:4567') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+        end
+      end
+=end
+    end
+  end
+
+  describe "GET" do
+    describe "basic" do
+      it "should perform a basic request" do
+        resp = Streamly.get('localhost:4567/?name=brian')
+        resp.should eql(@response)
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.get('localhost:4567').encoding.should eql(Encoding.find('utf-8'))
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.get('localhost:4567').encoding.should eql(Encoding.default_internal)
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.get('localhost:4567').encoding.should eql(Encoding.default_internal)
+        end
+      end
+=end
+    end
+
+    describe "streaming" do
+      it "should perform a basic request and stream the response to the caller" do
+        streamed_response = ''
+        resp = Streamly.get('localhost:4567/?name=brian') do |chunk|
+          chunk.should_not be_empty
+          streamed_response << chunk
+        end
+        resp.should be_nil
+        streamed_response.should eql(@response)
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.get('localhost:4567') do |chunk|
+            chunk.encoding.should eql(Encoding.find('utf-8'))
+          end
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.get('localhost:4567') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.get('localhost:4567') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+        end
+      end
+=end
+    end
+  end
+
+  describe "POST" do
+    describe "basic" do
+      it "should perform a basic request" do
+        resp = Streamly.post('localhost:4567', 'name=brian')
+        resp.should eql(@response)
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.post('localhost:4567', 'name=brian').encoding.should eql(Encoding.find('utf-8'))
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.post('localhost:4567', 'name=brian').encoding.should eql(Encoding.default_internal)
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.post('localhost:4567', 'name=brian').encoding.should eql(Encoding.default_internal)
+        end
+      end
+=end
+    end
+
+    describe "streaming" do
+      it "should perform a basic request and stream the response to the caller" do
+        streamed_response = ''
+        resp = Streamly.post('localhost:4567', 'name=brian') do |chunk|
+          chunk.should_not be_empty
+          streamed_response << chunk
+        end
+        resp.should be_nil
+        streamed_response.should eql(@response)
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.post('localhost:4567', 'name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.find('utf-8'))
+          end
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.post('localhost:4567', 'name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.post('localhost:4567', 'name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+        end
+      end
+=end
+    end
+  end
+
+  describe "PUT" do
+    describe "basic" do
+      it "should perform a basic request" do
+        resp = Streamly.put('localhost:4567', 'name=brian')
+        resp.should eql(@response)
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.put('localhost:4567', 'name=brian').encoding.should eql(Encoding.find('utf-8'))
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.put('localhost:4567', 'name=brian').encoding.should eql(Encoding.default_internal)
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.put('localhost:4567', 'name=brian').encoding.should eql(Encoding.default_internal)
+        end
+      end
+=end
+    end
+
+    describe "streaming" do
+      it "should perform a basic request and stream the response to the caller" do
+        streamed_response = ''
+        resp = Streamly.put('localhost:4567', 'name=brian') do |chunk|
+          chunk.should_not be_empty
+          streamed_response << chunk
+        end
+        resp.should be_nil
+        streamed_response.should eql(@response)
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.put('localhost:4567', 'name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.find('utf-8'))
+          end
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.put('localhost:4567', 'name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.put('localhost:4567', 'name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+        end
+      end
+=end
+    end
+  end
+
+  describe "DELETE" do
+    describe "basic" do
+      it "should perform a basic request" do
+        resp = Streamly.delete('localhost:4567/?name=brian').should eql(@response)
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.delete('localhost:4567/?name=brian').encoding.should eql(Encoding.find('utf-8'))
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.delete('localhost:4567/?name=brian').encoding.should eql(Encoding.default_internal)
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.delete('localhost:4567/?name=brian').encoding.should eql(Encoding.default_internal)
+        end
+      end
+=end
+    end
+
+    describe "streaming" do
+      it "should perform a basic request and stream the response to the caller" do
+        streamed_response = ''
+        resp = Streamly.delete('localhost:4567/?name=brian') do |chunk|
+          chunk.should_not be_empty
+          streamed_response << chunk
+        end
+        resp.should be_nil
+        streamed_response.should eql(@response)
+      end
+=begin
+      if RUBY_VERSION =~ /^1.9/
+        it "should default to utf-8 if Encoding.default_internal is nil" do
+          Encoding.default_internal = nil
+          Streamly.delete('localhost:4567/?name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.find('utf-8'))
+          end
+        end
+
+        it "should use Encoding.default_internal" do
+          Encoding.default_internal = Encoding.find('utf-8')
+          Streamly.delete('localhost:4567/?name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+          Encoding.default_internal = Encoding.find('us-ascii')
+          Streamly.delete('localhost:4567/?name=brian') do |chunk|
+            chunk.encoding.should eql(Encoding.default_internal)
+          end
+        end
+      end
+=end
+    end
+  end
+end