cool.io 1.2.0-x86-mingw32

data/lib/cool.io/eventmachine.rb

@@ -0,0 +1,234 @@
+#--
+# 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

@@ -0,0 +1,427 @@
+#--
+# 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 "cool.io/custom_require"
+cool_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(loop)
+  #   client.request('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
+      @state == :finished ? close : @state = :finished
+    end
+
+    # called by close
+    def on_close
+      if @state != :finished and @state == :body
+        on_request_complete
+      end
+    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