curb 0.1.4 → 0.3.1

data/ext/curb_multi.h

@@ -0,0 +1,25 @@
+/* curb_multi.h - Curl easy mode
+ * Copyright (c)2008 Todd A. Fisher. 
+ * Licensed under the Ruby License. See LICENSE for details.
+ * 
+ * $Id$
+ */
+#ifndef __CURB_MULTI_H
+#define __CURB_MULTI_H
+
+#include "curb.h"
+#include "curb_easy.h"
+#include <curl/multi.h>
+
+typedef struct {
+  int active;
+  int running;
+  VALUE requests; /* hash of handles currently added */
+  CURLM *handle;
+} ruby_curl_multi;
+
+extern VALUE cCurlMulti;
+void init_curb_multi();
+
+
+#endif

data/ext/curb_postfield.c

@@ -429,9 +429,10 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
 
   if ((rbcpf->local_file == Qnil) && (rbcpf->remote_file == Qnil)) {
     if (rbcpf->name != Qnil) {
-      char *tmpchrs;
+
+      char *tmpchrs = curl_escape(RSTRING_PTR(rbcpf->name), RSTRING_LEN(rbcpf->name));
       
-      if ((tmpchrs = curl_escape(StringValuePtr(rbcpf->name), RSTRING_LEN(rbcpf->name))) == NULL) {
+      if (!tmpchrs) {
         rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name `%s'", tmpchrs);
       } else {
         VALUE tmpcontent = Qnil;
@@ -445,8 +446,17 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
         } else {
           tmpcontent = rb_str_new2("");
         }
-        
-        if ((tmpchrs = curl_escape(StringValuePtr(tmpcontent), RSTRING_LEN(tmpcontent))) == NULL) {
+        if (TYPE(tmpcontent) != T_STRING) {
+          if (rb_respond_to(tmpcontent, rb_intern("to_s"))) {
+            tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
+          }
+          else {
+            rb_raise(rb_eRuntimeError, "postfield(%s) is not a string and does not respond_to to_s", RSTRING_PTR(escd_name) );
+          }
+        }
+        //fprintf(stderr, "encoding content: %ld - %s\n", RSTRING_LEN(tmpcontent), RSTRING_PTR(tmpcontent) );
+        tmpchrs = curl_escape(RSTRING_PTR(tmpcontent), RSTRING_LEN(tmpcontent));
+        if (!tmpchrs) {
           rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
         } else {
           VALUE escd_content = rb_str_new2(tmpchrs);

data/ext/extconf.rb

@@ -2,23 +2,120 @@ require 'mkmf'
 
 dir_config('curl')
 
-unless have_library('curl') &&
-       have_header('curl/curl.h')
+if find_executable('curl-config')
+  $CFLAGS << " #{`curl-config --cflags`.strip}"
+  $LIBS << " #{`curl-config --libs`.strip}"
+elsif !have_library('curl') or !have_header('curl/curl.h')
   fail <<-EOM
   Can't find libcurl or curl/curl.h
-  
+
   Try passing --with-curl-dir or --with-curl-lib and --with-curl-include
   options to extconf.
   EOM
 end
 
-#install_rb("curb.rb", "$(RUBYLIBDIR)", '../lib')
-#install_rb("curl.rb", "$(RUBYLIBDIR)", '../lib')
-$INSTALLFILES = [["curb.rb", "$(RUBYLIBDIR)", "../ext"], ["curl.rb", "$(RUBYLIBDIR)", "../ext"]]
+def define(s)
+  $defs.push( format("-D HAVE_%s", s.to_s.upcase) )
+end
+
+def have_constant(name)
+  checking_for name do
+    src = %{
+      #include <curl/curl.h>
+      int main() {
+        int test = (int)#{name.upcase};
+        return 0;
+      }
+    }
+    if try_compile(src,"#{$CFLAGS} #{$LIBS}")
+      define name
+      true
+    else
+      false
+    end
+  end
+end
+
+have_constant "curlinfo_redirect_time"
+have_constant "curlinfo_response_code"
+have_constant "curlinfo_filetime"
+have_constant "curlinfo_redirect_count"
+have_constant "curlinfo_os_errno"
+have_constant "curlinfo_num_connects"
+have_constant "curlinfo_ftp_entry_path"
+have_constant "curl_version_ssl"
+have_constant "curl_version_libz"
+have_constant "curl_version_ntlm"
+have_constant "curl_version_gssnegotiate"
+have_constant "curl_version_debug"
+have_constant "curl_version_asynchdns"
+have_constant "curl_version_spnego"
+have_constant "curl_version_largefile"
+have_constant "curl_version_idn"
+have_constant "curl_version_sspi"
+have_constant "curl_version_conv"
+have_constant "curlproxy_http"
+have_constant "curlproxy_socks4"
+have_constant "curlproxy_socks5"
+have_constant "curlauth_basic"
+have_constant "curlauth_digest"
+have_constant "curlauth_gssnegotiate"
+have_constant "curlauth_ntlm"
+have_constant "curlauth_anysafe"
+have_constant "curlauth_any"
+have_constant "curle_tftp_notfound"
+have_constant "curle_tftp_perm"
+have_constant "curle_tftp_diskfull"
+have_constant "curle_tftp_illegal"
+have_constant "curle_tftp_unknownid"
+have_constant "curle_tftp_exists"
+have_constant "curle_tftp_nosuchuser"
+# older versions of libcurl 7.12
+have_constant "curle_send_fail_rewind"
+have_constant "curle_ssl_engine_initfailed"
+have_constant "curle_login_denied"
 
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end
 
-create_makefile('curb_core')
+# do some checking to detect ruby 1.8 hash.c vs ruby 1.9 hash.c
+def test_for(name, const, src)
+  checking_for name do
+    if try_compile(src,"#{$CFLAGS} #{$LIBS}")
+      define const
+      true
+    else
+      false
+    end
+  end
+end
+test_for("Ruby 1.9 Hash", "RUBY19_HASH", %{
+  #include <ruby.h>
+  int main() {
+    VALUE hash = rb_hash_new();
+    if( RHASH(hash)->ntbl->num_entries ) {
+      return 0;
+    }
+    return 1;
+  }
+})
+test_for("Ruby 1.9 st.h", "RUBY19_ST_H", %{
+  #include <ruby.h>
+  #include <ruby/st.h>
+  int main() {
+    return 0;
+  }
+})
 
+test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
+  #include <curl/curl.h>
+  int main() {
+    CURL *easy = curl_easy_init();
+    curl_easy_escape(easy,"hello",5);
+    return 0;
+  }
+})
+
+create_header('curb_config.h')
+create_makefile('curb_core')

data/{ext → lib}/curb.rb

@@ -39,6 +39,8 @@ module Curl
           
           curl.perform
         end        
+
+        return curl
       end
     end
   end

data/tests/bug_curb_easy_blocks_ruby_threads.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), 'helper')
+require 'webrick'
+class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
+class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
+
+class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
+  def test_bug
+    server = WEBrick::HTTPServer.new( :Port => 9999 )
+    server.mount_proc("/test") do|req,res|
+      sleep 0.5
+      res.body = "hi"
+      res['Content-Type'] = "text/html"
+    end
+
+    thread = Thread.new(server) do|srv|
+      srv.start
+    end
+
+    threads = []
+    timer = Time.now
+
+    5.times do |i|
+      t = Thread.new do
+        c = Curl::Easy.perform('http://localhost:9999/test')
+        c.header_str
+      end
+      threads << t
+    end
+
+    multi_responses = threads.collect do|t|
+      t.value
+    end
+
+    multi_time = (Time.now - timer)
+    puts "requested in #{multi_time}"
+
+    timer = Time.now
+    single_responses = []
+    5.times do |i|
+      c = Curl::Easy.perform('http://localhost:9999/test')
+      single_responses << c.header_str
+    end
+    
+    single_time = (Time.now - timer)
+    puts "requested in #{single_time}"
+
+    assert single_time > multi_time
+
+    server.shutdown
+    thread.join
+  end
+end

data/tests/helper.rb

@@ -13,3 +13,144 @@ require 'curb'
 require 'test/unit'
 
 $TEST_URL = "file://#{URI.escape(File.expand_path(__FILE__).tr('\\','/').tr(':','|'))}"
+
+require 'thread'
+require 'webrick'
+
+# set this to true to avoid testing with multiple threads
+# or to test with multiple threads set it to false
+# this is important since, some code paths will change depending
+# on the presence of multiple threads
+TEST_SINGLE_THREADED=false
+
+# keep webrick quiet
+class ::WEBrick::HTTPServer
+  def access_log(config, req, res)
+    # nop
+  end
+end
+class ::WEBrick::BasicLog
+  def log(level, data)
+    # nop
+  end
+end
+
+#
+# Simple test server to record number of times a request is sent/recieved of a specific 
+# request type, e.g. GET,POST,PUT,DELETE
+#
+class TestServlet < WEBrick::HTTPServlet::AbstractServlet
+
+  def self.port=(p)
+    @port = p
+  end
+
+  def self.port
+    (@port or 9129)
+  end
+
+  def self.path
+    '/methods'
+  end
+
+  def self.url
+    "http://127.0.0.1:#{port}#{path}"
+  end
+
+  def respond_with(method,req,res)
+    res.body = method.to_s
+    res['Content-Type'] = "text/plain"
+  end
+
+  def do_GET(req,res)
+    respond_with(:GET,req,res)
+  end
+
+  def do_HEAD(req,res)
+    res['Location'] = "/nonexistent"
+    respond_with(:HEAD, req, res)
+  end
+
+  def do_POST(req,res)
+    respond_with(:POST,req,res)
+  end
+
+  def do_PUT(req,res)
+    respond_with("PUT\n#{req.body}",req,res)
+  end
+
+  def do_DELETE(req,res)
+    respond_with(:DELETE,req,res)
+  end
+
+end
+
+module TestServerMethods
+  def locked_file
+    File.join(File.dirname(__FILE__),"server_lock-#{@__port}")
+  end
+
+  def server_setup(port=9129,servlet=TestServlet)
+    @__port = port
+    if @server.nil? and !File.exist?(locked_file)
+
+      File.open(locked_file,'w') {|f| f << 'locked' }
+      if TEST_SINGLE_THREADED
+        rd, wr = IO.pipe
+        @__pid = fork do
+          rd.close
+          rd = nil
+
+          # start up a webrick server for testing delete 
+          server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+          server.mount(servlet.path, servlet)
+          trap("INT") { server.shutdown }
+          GC.start
+          wr.flush
+          wr.close
+          server.start
+        end
+        wr.close
+        rd.read
+        rd.close
+      else
+        # start up a webrick server for testing delete 
+        @server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+        @server.mount(servlet.path, servlet)
+        queue = Queue.new # synchronize the thread startup to the main thread
+
+        @test_thread = Thread.new { queue << 1; @server.start }
+
+        # wait for the queue
+        value = queue.pop
+        if !value
+          STDERR.puts "Failed to startup test server!"
+          exit(1)
+        end
+
+      end
+
+      exit_code = lambda do
+        begin
+          if File.exist?(locked_file)
+            File.unlink locked_file
+            if TEST_SINGLE_THREADED
+              Process.kill 'INT', @__pid
+            else
+              @server.shutdown unless @server.nil?
+            end
+          end
+          #@server.shutdown unless @server.nil?
+        rescue Object => e
+          puts "Error #{__FILE__}:#{__LINE__}\n#{e.message}"
+        end
+      end
+
+      trap("INT"){exit_code.call}
+      at_exit{exit_code.call}
+
+    end
+  end
+end

data/tests/tc_curl_download.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestCurbCurlDownload < Test::Unit::TestCase
+  include TestServerMethods 
+
+  def setup
+    server_setup(9130)
+  end
+  
+  def test_download_url_to_file
+    dl_url = "http://127.0.0.1:9130/ext/curb_easy.c"
+    dl_path = File.join("/tmp/dl_url_test.file")
+
+    curb = Curl::Easy.download(dl_url, dl_path)
+    assert File.exist?(dl_path)
+  end
+
+  def test_download_bad_url_gives_404
+    dl_url = "http://127.0.0.1:9130/this_file_does_not_exist.html"
+    dl_path = File.join("/tmp/dl_url_test.file")
+
+    curb = Curl::Easy.download(dl_url, dl_path)
+    assert_equal Curl::Easy, curb.class
+    assert_equal 404, curb.response_code
+  end
+
+end

data/tests/tc_curl_easy.rb

@@ -86,7 +86,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
 
   def test_get_01   
     c = Curl::Easy.new($TEST_URL)    
-    assert_equal true, c.http_get    
+    assert_equal true, c.http_get
     assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
     assert_equal "", c.header_str
   end    
@@ -110,7 +110,8 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal "", c.body_str
     assert_equal "", c.header_str
   end    
-  
+
+
   def test_last_effective_url_01
     c = Curl::Easy.new($TEST_URL)
     
@@ -438,5 +439,68 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal "some.file", c.cookiejar = "some.file"
     assert_equal "some.file", c.cookiejar        
   end
+
+  def test_on_success
+    curl = Curl::Easy.new($TEST_URL)    
+    on_success_called = false
+    curl.on_success {|c|
+      on_success_called = true
+      assert_not_nil c.body_str
+      assert_equal "", c.header_str
+      assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
+    }
+    curl.perform
+    assert on_success_called, "Success handler not called" 
+  end
+
+  def test_on_success_with_on_failure
+    curl = Curl::Easy.new("#{$TEST_URL.gsub(/file:\/\//,'')}/not_here")
+    on_failure_called = false
+    curl.on_success {|c| } # make sure we get the failure call even though this handler is defined
+    curl.on_failure {|c| on_failure_called = true }
+    curl.perform
+    assert on_failure_called, "Failure handler not called" 
+  end
+  
+  def test_get_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_get
+    assert_equal 'GET', curl.body_str
+  end
   
-end
+  def test_post_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_post
+    assert_equal 'POST', curl.body_str
+  end
+
+  def test_delete_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_delete
+    assert_equal 'DELETE', curl.body_str
+  end
+
+  def test_head_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_head
+
+    redirect = curl.header_str.match(/Location: (.*)/)
+
+    assert_equal '', curl.body_str
+    assert_match '/nonexistent', redirect[1]
+  end
+
+  def test_put_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    assert curl.http_put("message")
+    assert_match /^PUT/, curl.body_str
+    assert_match /message$/, curl.body_str
+  end
+
+  include TestServerMethods 
+
+  def setup
+    server_setup
+  end
+
+end