cool.io 1.0.0 → 1.9.0

data/lib/cool.io/eventmachine.rb

@@ -1,234 +0,0 @@
-#--
-# Copyright (C)2007-10 Tony Arcieri, Roger Pack
-# You can redistribute this under the terms of the Ruby license
-# See file LICENSE for details
-#++
-
-require 'cool.io'
-
-# EventMachine emulation for Cool.io:
-#
-#   require 'coolio/eventmachine'
-#
-# Drawbacks: slightly slower than EM.
-# Benefits: timers are more accurate using libev than using EM
-# TODO: some things like connection timeouts aren't implemented yet
-# DONE: timers and normal socket functions are implemented.
-module EventMachine
-  class << self
-    # Start the Reactor loop
-    def run
-      yield if block_given?
-      Coolio::Loop.default.run
-    end
-
-    # Stop the Reactor loop
-    def stop_event_loop
-      Coolio::Loop.default.stop
-    end
-
-    class OneShotEMTimer < Coolio::TimerWatcher
-      def setup(proc)
-        @proc = proc
-      end
-
-      def on_timer
-       @proc.call
-      end
-    end
-
-    # ltodo: use Coolio's PeriodicTimer to wrap EM's two similar to it
-    # todo: close all connections on 'stop', I believe
-
-    def add_timer(interval, proc = nil, &block)
-      block ||= proc
-      t = OneShotEMTimer.new(interval, false) # non repeating
-      t.setup(block) 
-      
-      # fire 'er off ltodo: do we keep track of these timers in memory?
-      t.attach(Coolio::Loop.default)
-      t
-    end
-
-    def cancel_timer(t)
-      # guess there's a case where EM you can say 'cancel' but it's already fired?
-      # kind of odd but it happens
-     t.detach if t.attached? 
-    end
-
-    def set_comm_inactivity_timeout(*args); end # TODO
-
-    # Make an outgoing connection
-    def connect(addr, port, handler = Connection, *args, &block)
-      block = args.pop if Proc === args[-1]
-
-      # make sure we're a 'real' class here
-      klass = if (handler and handler.is_a?(Class))
-        handler
-      else
-        Class.new( Connection ) {handler and include handler}
-      end
-
-      wrapped_child = CallsBackToEM.connect(addr, port, *args) # ltodo: args? what? they're used? also TODOC TODO FIX
-      conn = klass.new(wrapped_child) # ltodo [?] addr, port, *args)
-      wrapped_child.attach(Coolio::Loop.default) # necessary
-      conn.heres_your_socket(wrapped_child)
-      wrapped_child.call_back_to_this(conn) # calls post_init for us
-      yield conn if block_given?
-    end
-    
-    # Start a TCP server on the given address and port
-    def start_server(addr, port, handler = Connection, *args, &block)
-      # make sure we're a 'real' class here
-      klass = if (handler and handler.is_a?(Class))
-        handler
-      else
-        Class.new( Connection ) {handler and include handler}
-      end
-      
-      server = Coolio::TCPServer.new(addr, port, CallsBackToEM, *args) do |wrapped_child| 
-        conn = klass.new(wrapped_child)
-        conn.heres_your_socket(wrapped_child) # ideally NOT have this :)
-        wrapped_child.call_back_to_this(conn) 
-        block.call(conn) if block
-      end
-
-      server.attach(Coolio::Loop.default)
-    end
-
-    def stop_server(server)
-      server.close
-    end
-
-    # Set the maximum number of descriptors available to this process
-    def set_descriptor_table_size(nfds)
-      Coolio::Utils.maxfds = nfds
-    end
-
-    # Compatibility noop.  Handled automatically by libev
-    def epoll; end
-
-    # Compatibility noop.  Handled automatically by libev
-    def kqueue; end
-  end
-
-  class CallsBackToEM < Coolio::TCPSocket
-    class ConnectTimer < Coolio::TimerWatcher
-      attr_accessor :parent
-      def on_timer
-       @parent.connection_has_timed_out
-      end
-    end
-
-    def call_back_to_this parent
-      @call_back_to_this = parent
-      parent.post_init
-    end
-
-    def on_connect
-      # @connection_timer.detach if @connection_timer 
-      # won't need that anymore :) -- with server connecteds we don't have it, anyway
-      
-      # TODO should server accepted's call this? They don't currently
-      # [and can't, since on_connect gets called basically in the initializer--needs some code love for that to happen :)
-      @call_back_to_this.connection_completed if @call_back_to_this
-    end
-
-    def connection_has_timed_out
-      return if closed?
-      
-      # wonder if this works when you're within a half-connected phase.
-      # I think it does.  What about TCP state?
-      close unless closed? 
-      @call_back_to_this.unbind
-    end
-
-    def on_write_complete
-      close if @should_close_after_writing
-    end
-
-    def should_close_after_writing
-      @should_close_after_writing = true;
-    end
-
-    def on_close
-      @call_back_to_this.unbind # about the same ltodo check if they ARE the same here
-    end
-
-    def on_resolve_failed
-      fail
-    end
-
-    def on_connect_failed
-      fail
-    end
-
-    def on_read(data)
-      @call_back_to_this.receive_data data
-    end
-
-    def fail
-      #@connection_timer.detch if @connection_timer
-      @call_back_to_this.unbind
-    end
-
-    def self.connect(*args)
-      a = super *args
-      # the connect timer currently kills TCPServer classes.  I'm not sure why.
-      #@connection_timer = ConnectTimer.new(14) # needs to be at least higher than 12 :)
-      #@connection_timer.parent = a
-      #@connection_timer.attach(Coolio::Loop.default)
-      a
-    end
-  end
-
-  class Connection
-    def self.new(*args)
-      allocate#.instance_eval do
-      #  initialize *args
-      #end
-    end
-    
-    # we will need to call 'their functions' appropriately -- the commented out ones, here
-    # 
-    # Callback fired when connection is created
-    def post_init
-      # I thought we were 'overriding' EM's existing methods, here.  
-      # Huh? Why do we have to define these then?
-    end
-
-    # Callback fired when connection is closed
-    def unbind; end
-    
-    # Callback fired when data is received
-    # def receive_data(data); end
-    def heres_your_socket(instantiated_coolio_socket)
-      instantiated_coolio_socket.call_back_to_this self
-      @wrapped_coolio = instantiated_coolio_socket
-    end
-
-    # Send data to the current connection -- called by them
-    def send_data(data)
-      @wrapped_coolio.write data
-    end
-    
-    # Close the connection, optionally after writing
-    def close_connection(after_writing = false)
-      return close_connection_after_writing if after_writing
-      @wrapped_coolio.close
-    end
-    
-    # Close the connection after all data has been written
-    def close_connection_after_writing
-      @wrapped_coolio.output_buffer_size.zero? ? @wrapped_coolio.close : @wrapped_coolio.should_close_after_writing
-    end
-
-    def get_peername
-      family, port, host_name, host_ip = @wrapped_coolio.peeraddr
-      Socket.pack_sockaddr_in(port, host_ip) # pack it up :)
-    end
-  end
-end
-
-# Shortcut constant
-EM = EventMachine

data/lib/cool.io/http_client.rb

@@ -1,419 +0,0 @@
-#--
-# Copyright (C)2007-10 Tony Arcieri
-# Includes portions originally Copyright (C)2005 Zed Shaw
-# You can redistribute this under the terms of the Ruby license
-# See file LICENSE for details
-#++
-
-require 'http11_client'
-
-module Coolio
-  # A simple hash is returned for each request made by HttpClient with
-  # the headers that were given by the server for that request.
-  class HttpResponseHeader < Hash
-    # The reason returned in the http response ("OK","File not found",etc.)
-    attr_accessor :http_reason
-
-    # The HTTP version returned.
-    attr_accessor :http_version
-
-    # The status code (as a string!)
-    attr_accessor :http_status
-
-    # HTTP response status as an integer
-    def status
-      Integer(http_status) rescue nil
-    end
-
-    # Length of content as an integer, or nil if chunked/unspecified
-    def content_length
-      Integer(self[HttpClient::CONTENT_LENGTH]) rescue nil
-    end
- 
-    # Is the transfer encoding chunked?
-    def chunked_encoding?
-      /chunked/i === self[HttpClient::TRANSFER_ENCODING]
-    end
- end
-
-  class HttpChunkHeader < Hash
-    # When parsing chunked encodings this is set
-    attr_accessor :http_chunk_size
-
-    # Size of the chunk as an integer
-    def chunk_size
-      return @chunk_size unless @chunk_size.nil?
-      @chunk_size = @http_chunk_size ? @http_chunk_size.to_i(base=16) : 0
-    end
-  end
-
-  # Methods for building HTTP requests
-  module HttpEncoding
-    HTTP_REQUEST_HEADER="%s %s HTTP/1.1\r\n"
-    FIELD_ENCODING = "%s: %s\r\n"
-
-    # Escapes a URI.
-    def escape(s)
-      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-        '%'+$1.unpack('H2'*$1.size).join('%').upcase
-      }.tr(' ', '+') 
-    end
-
-    # Unescapes a URI escaped string.
-    def unescape(s)
-      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
-        [$1.delete('%')].pack('H*')
-      } 
-    end
-
-    # Map all header keys to a downcased string version
-    def munge_header_keys(head)
-      head.inject({}) { |h, (k, v)| h[k.to_s.downcase] = v; h }
-    end
-
-    # HTTP is kind of retarded that you have to specify
-    # a Host header, but if you include port 80 then further
-    # redirects will tack on the :80 which is annoying.
-    def encode_host
-      remote_host + (remote_port.to_i != 80 ? ":#{remote_port}" : "")
-    end
-
-    def encode_request(method, path, query)
-      HTTP_REQUEST_HEADER % [method.to_s.upcase, encode_query(path, query)]
-    end
-
-    def encode_query(path, query)
-      return path unless query
-      path + "?" + query.map { |k, v| encode_param(k, v) }.join('&')
-    end
-
-    # URL encodes a single k=v parameter.
-    def encode_param(k, v)
-      escape(k) + "=" + escape(v)
-    end
-
-    # Encode a field in an HTTP header
-    def encode_field(k, v)
-      FIELD_ENCODING % [k, v]
-    end
-
-    def encode_headers(head)
-      head.inject('') do |result, (key, value)|
-        # Munge keys from foo-bar-baz to Foo-Bar-Baz
-        key = key.split('-').map { |k| k.capitalize }.join('-')
-      result << encode_field(key, value)
-      end
-    end
-
-    def encode_cookies(cookies)
-      cookies.inject('') { |result, (k, v)| result << encode_field('Cookie', encode_param(k, v)) }
-    end
-  end
-
-  # HTTP client class implemented as a subclass of Coolio::TCPSocket.  Encodes
-  # requests and allows streaming consumption of the response.  Response is
-  # parsed with a Ragel-generated whitelist parser which supports chunked
-  # HTTP encoding.
-  #
-  # == Example
-  #
-  #   loop = Coolio::Loop.default
-  #   client = Coolio::HttpClient.connect("www.google.com").attach
-  #   client.get('/search', query: {q: 'foobar'})
-  #   loop.run
-  #
-  class HttpClient < TCPSocket
-    include HttpEncoding
-
-    ALLOWED_METHODS=[:put, :get, :post, :delete, :head]
-    TRANSFER_ENCODING="TRANSFER_ENCODING"
-    CONTENT_LENGTH="CONTENT_LENGTH"
-    SET_COOKIE="SET_COOKIE"
-    LOCATION="LOCATION"
-    HOST="HOST"
-    CRLF="\r\n"
-
-    # Connect to the given server, with port 80 as the default
-    def self.connect(addr, port = 80, *args)
-      super
-    end
-
-    def initialize(socket)
-      super
-
-      @parser = HttpClientParser.new
-      @parser_nbytes = 0
-
-      @state = :response_header
-      @data = ::IO::Buffer.new
-
-      @response_header = HttpResponseHeader.new
-      @chunk_header = HttpChunkHeader.new
-    end
-
-    # Send an HTTP request and consume the response.  
-    # Supports the following options:
-    #
-    #   head: {Key: Value}
-    #     Specify an HTTP header, e.g. {'Connection': 'close'} 
-    #
-    #   query: {Key: Value}
-    #     Specify query string parameters (auto-escaped)
-    #
-    #   cookies: {Key: Value}
-    #     Specify hash of cookies (auto-escaped)
-    #
-    #   body: String
-    #     Specify the request body (you must encode it for now)
-    #
-    def request(method, path, options = {})
-      raise ArgumentError, "invalid request path" unless /^\// === path
-      raise RuntimeError, "request already sent" if @requested
-
-      @method, @path, @options = method, path, options
-      @requested = true
-
-      return unless @connected
-      send_request
-    end
-    
-    # Enable the HttpClient if it has been disabled
-    def enable
-      super
-      dispatch unless @data.empty?
-    end
-
-    # Called when response header has been received
-    def on_response_header(response_header)
-    end
-
-    # Called when part of the body has been read
-    def on_body_data(data)
-      STDOUT.write data
-      STDOUT.flush
-    end
-
-    # Called when the request has completed
-    def on_request_complete
-      close
-    end
-
-    # Called when an error occurs dispatching the request
-    def on_error(reason)
-      close
-      raise RuntimeError, reason
-    end
-
-    #########
-    protected
-    #########
-
-    #
-    # Coolio callbacks
-    #
-        
-    def on_connect
-      @connected = true
-      send_request if @method and @path
-    end
-
-    def on_read(data)
-      @data << data
-      dispatch
-    end
-
-    #
-    # Request sending
-    #
-
-    def send_request
-      send_request_header
-      send_request_body
-    end
-
-    def send_request_header
-      query   = @options[:query]
-      head    = @options[:head] ? munge_header_keys(@options[:head]) : {}
-      cookies = @options[:cookies]
-      body    = @options[:body]
-
-      # Set the Host header if it hasn't been specified already
-      head['host'] ||= encode_host
-
-      # Set the Content-Length if it hasn't been specified already and a body was given
-      head['content-length'] ||= body ? body.length : 0
-
-      # Set the User-Agent if it hasn't been specified
-      head['user-agent'] ||= "Coolio #{Coolio::VERSION}"
-
-      # Default to Connection: close
-      head['connection'] ||= 'close'
-
-      # Build the request
-      request_header = encode_request(@method, @path, query)
-      request_header << encode_headers(head)
-      request_header << encode_cookies(cookies) if cookies
-      request_header << CRLF
-
-      write request_header
-    end
-
-    def send_request_body
-      write @options[:body] if @options[:body]
-    end  
- 
-    #
-    # Response processing
-    #
-
-    def dispatch
-      while enabled? and case @state
-        when :response_header
-          parse_response_header
-        when :chunk_header
-          parse_chunk_header
-        when :chunk_body
-          process_chunk_body
-        when :chunk_footer
-          process_chunk_footer
-        when :response_footer
-          process_response_footer
-        when :body
-          process_body
-        when :finished, :invalid
-          break
-        else raise RuntimeError, "invalid state: #{@state}"
-        end
-      end
-    end
-
-    def parse_header(header)
-      return false if @data.empty?
-      
-      begin
-        @parser_nbytes = @parser.execute(header, @data.to_str, @parser_nbytes)
-      rescue Coolio::HttpClientParserError
-        on_error "invalid HTTP format, parsing fails"
-        @state = :invalid
-      end
-      
-      return false unless @parser.finished?
-
-      # Clear parsed data from the buffer
-      @data.read(@parser_nbytes)
-      @parser.reset
-      @parser_nbytes = 0
-      
-      true
-    end
-
-    def parse_response_header
-      return false unless parse_header(@response_header)
-
-      unless @response_header.http_status and @response_header.http_reason
-        on_error "no HTTP response"
-        @state = :invalid
-        return false
-      end
-
-      on_response_header(@response_header)
-
-      if @response_header.chunked_encoding?
-        @state = :chunk_header
-      else
-        @state = :body
-        @bytes_remaining = @response_header.content_length
-      end
-      
-      true
-    end
-
-    def parse_chunk_header
-      return false unless parse_header(@chunk_header)
-
-      @bytes_remaining = @chunk_header.chunk_size
-      @chunk_header = HttpChunkHeader.new
-
-      @state = @bytes_remaining > 0 ? :chunk_body : :response_footer      
-      true
-    end
-
-    def process_chunk_body
-      if @data.size < @bytes_remaining
-        @bytes_remaining -= @data.size
-        on_body_data @data.read
-        return false
-      end
-
-      on_body_data @data.read(@bytes_remaining)
-      @bytes_remaining = 0
-      
-      @state = :chunk_footer      
-      true
-    end
-
-    def process_chunk_footer
-      return false if @data.size < 2
-
-      if @data.read(2) == CRLF
-        @state = :chunk_header
-      else
-        on_error "non-CRLF chunk footer"
-        @state = :invalid
-      end
-      
-      true
-    end
-
-    def process_response_footer
-      return false if @data.size < 2
-      
-      if @data.read(2) == CRLF
-        if @data.empty?
-          on_request_complete
-          @state = :finished
-        else
-          on_error "garbage at end of chunked response"
-          @state = :invalid
-        end
-      else
-        on_error "non-CRLF response footer"
-        @state = :invalid
-      end
-      
-      false
-    end
-
-    def process_body
-      if @bytes_remaining.nil?
-        on_body_data @data.read
-        return false
-      end
-      
-      if @bytes_remaining.zero?
-        on_request_complete
-        @state = :finished
-        return false
-      end
-
-      if @data.size < @bytes_remaining
-        @bytes_remaining -= @data.size
-        on_body_data @data.read
-        return false
-      end
-
-      on_body_data @data.read(@bytes_remaining)
-      @bytes_remaining = 0
-
-      if @data.empty?
-        on_request_complete
-        @state = :finished
-      else
-        on_error "garbage at end of body"
-        @state = :invalid
-      end
-
-      false
-    end
-  end
-end

data/lib/rev.rb

@@ -1,4 +0,0 @@
-STDERR.puts "*** DEPRECATION WARNING: require 'rev' and the Rev constant are deprecated. Please use require 'cool.io' and the Coolio constant instead"
-
-require 'cool.io'
-Rev = Coolio

data/spec/possible_tests/schedules_other_threads.rb

@@ -1,48 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/rev'
-def dbg
- require 'rubygems'
- require 'ruby-debug'
- debugger
-end
-Thread.abort_on_exception=true
-
-require 'socket'
-
-describe Rev::TCPSocket do
-      HOST = '127.0.0.1'
-      PORT = 4321
-  before :each do
-      @server = Rev::TCPServer.new(HOST, PORT) do |c|
-         c.on_connect { puts "#{remote_addr}:#{remote_port} connected" }
-         c.on_close   { puts "#{remote_addr}:#{remote_port} disconnected" }
-         #c.on_read    { |data| write data }
-      end
-
-  end
-
-  after :each do
-	@server.close
-  end
-
-  def sleep_until(seconds = 1, interval = 0.1)
-   raise unless block_given?
-   start_time=Time.now
-   sleep interval until ((Time.now - start_time) > seconds) or yield
-  end
-
-  it "should stop" do
-	loop = Rev::Loop.default
-	stopped = false;
-  	@server.attach(loop)
-  	Thread.new {
-                loop.run
-		stopped = true
-        }
-	sleep 0
-        stopped.should == false
-        loop.stop
-        sleep_until(3) { stopped == true }
-        stopped.should == true
-   end
-end
-

data/spec/possible_tests/test_on_resolve_failed.rb

@@ -1,9 +0,0 @@
-require '../rev'
-class Tester < Rev::TCPSocket
-  def on_resolve_failed
-    print "resolved failed! that's good!"
-  end
-end
-a = Tester.connect('asdfgoogle.com', 80)
-a.attach Rev::Loop.default
-Rev::Loop.default.run