internethakai 0.2.0

data/lib/internethakai/hakairev/http_client.rb.~1~

@@ -0,0 +1,371 @@
+module InternetHakai
+    class RevHttpConnection < Rev::HttpClient
+        def initialize args
+            @remote_addr, @remote_port = args
+            soc = TCPConnectSocket::new(::Socket::AF_INET, @remote_addr, @remote_port)
+            super(soc)
+        end
+        def init
+            @content = ''
+            @writable_flag = false
+            @send_flag = false
+            @busy = false
+            @on_request_complete = nil
+            @requested = false
+            @response_object = InternetHakai::ResponseObject::new
+            self
+        end
+        attr_reader :connected, :busy
+        def on_read s
+            super
+        end
+        def on_readable
+            begin
+                on_read @_io.read_nonblock(INPUT_SIZE)
+            rescue Errno::EAGAIN
+            rescue Errno::ECONNRESET, EOFError
+            rescue IOError => e
+                @exception = e
+                on_error('io error')
+            rescue Exception => e
+                @exception = e
+                on_error('io error')
+            end
+        end
+        def reconnect
+            @requested = false
+            @busy = false
+            free
+            socket = TCPConnectSocket::new(::Socket::AF_INET, @remote_addr, @remote_port)
+
+            @_io = socket
+            #@_write_buffer  ||= ::IO::Buffer.new
+            @_read_watcher  = Watcher.new(socket, self, :r)
+            @_write_watcher = Watcher.new(socket, self, :w)
+            @address_family, @remote_port, @remote_host, @remote_addr = socket.peeraddr
+
+
+            @state = :response_header
+            #@data = ::IO::Buffer.new
+
+            @response_header = Rev::HttpResponseHeader.new
+            @chunk_header = Rev::HttpChunkHeader.new
+            #initialize(socket)
+
+            @_connector = Connector::new(self, socket)
+            @_connector.attach(@loop)
+        end
+        def close
+            super
+        end
+        def on_writable
+            @writable_flag = true unless @writable_flag
+            # writable + send 両方そろったら開始時間
+            if @send_flag && !@starttime
+                @starttime = Time::now
+            end
+            begin
+                @_write_buffer.write_to(@_io)
+
+            rescue Errno::EPIPE, Errno::ECONNRESET => e
+            rescue IOError => e
+            rescue Exception => e
+                @exception = e
+                on_error('io error')
+            end
+            if @_write_buffer.empty?
+                disable_write_watcher
+                on_write_complete
+            end
+        end
+        def send_request
+            @send_flag = true
+            @starttime = Time::now
+            super
+        end
+        def attached?
+            if @_connector
+                @_connector.attached?
+            elsif @_read_watcher
+                @_read_watcher.attached?
+            elsif @_resolver
+                @_resolver.attached
+            else
+                super
+            end
+        end
+        def on_body_data(data)
+            @content += data
+        end
+        def on_request_complete
+            @response_time = Time::now - @starttime
+            self.close
+        end
+        def on_connect_failed
+            @exception = SocketError::new('connection error')
+            on_error('')
+        end
+        def on_resolve_failed
+            @exception = SocketError::new('dns error')
+            on_error('')
+        end
+        def on_failure
+            @exception = SocketError::new
+            on_error('')
+        end
+        def on_error(reason='error')
+            unless @starttime.nil?
+                @response_time = Time::now - @starttime
+            else
+                @response_time = 0
+            end
+            close if @_io and !@_io.closed?
+            @requested = false
+            @exception = reason if @exception.nil?
+            @busy = false
+        end
+        def to_response_object
+            r = @response_object
+            r.body = @content.to_s
+            r.status = @response_header.http_status.to_i
+            r.content_type = @response_header["CONTENT_TYPE"].to_s
+            r.location = @response_header["LOCATION"]
+            r.time = @response_time
+            r
+        end
+        def attach lp
+            @loop = lp unless @loop
+            if @_connector
+                @_connector.attach lp
+            elsif @_read_watcher
+                @_read_watcher.attach(lp)
+            elsif @_resolver
+                @_resolver.attache lp
+            else
+                return
+            end
+        end
+=begin
+        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)
+
+            @state = :body
+            @bytes_remaining = @response_header.content_length
+
+            true
+        end
+=end
+=begin
+        def parse_header(header)
+            return false if @data.empty?
+
+            key = nil
+            if idx = @data.to_str.index("\r\n\r\n")
+                ctx = idx + 4
+                key = @data.to_str[0, ctx]
+                #key = Digest::MD5::digest(@data.to_str[0, ctx])
+                if obj = searchcache(key)
+                    @parser_nbytes = 0
+                    @data.read(ctx)
+                    @parser.reset
+                    @response_header = obj
+                    return true
+                end
+            end
+            begin
+                @parser_nbytes = @parser.execute(header, @data.to_str, @parser_nbytes)
+            rescue Rev::HttpClientParserError
+                on_error "invalid HTTP format, parsing fails"
+                @state = :invalid
+            end
+
+            return false unless @parser.finished?
+
+            if key
+                insertcache(key, header)
+            end
+
+            # Clear parsed data from the buffer
+            @data.read(@parser_nbytes)
+            @parser.reset
+            @parser_nbytes = 0
+
+            true
+        end
+=end
+        @@_cache = {}
+        @@_cache_keys = []
+        @@_cache_max = 200
+        def insertcache key, data
+            @@_cache[key] = data.dup
+            if @@_cache_keys.size > @@_cache_max
+                @@_cache.delete(@@_cache_keys.shift)
+            end
+        end
+        def searchcache key
+            if @@_cache.has_key?(key)
+                @@_cache_keys << key
+                @@_cache[key]
+            else
+                nil
+            end
+        end
+        def free
+            @content = ''
+            #@response_header = nil
+            #@chunk_header = nil
+            @response_time = nil
+            @_write_buffer.clear
+            #@_write_buffer = nil
+            @_read_watcher.detach if @_read_watcher.attached?
+            #@_read_watcher = nil
+            @_write_watcher.detach if @_write_watcher.attached?
+            #@_write_watcher = nil
+            @data.clear
+            #@data = nil
+            #@path = nil
+            #@method = nil
+            #@options = nil
+            #@starttime = nil
+            #@_io = nil
+            @writable_flag = nil
+            @send_flag = nil
+            @connected = false
+        end
+    end
+    class RevHttpClient < RevHttpConnection
+        def self::create host, port
+            #o = self::create_from_port(host, port)
+            o = self::new([host, port])
+            o.attach(Rev::Loop::default)
+            o.prepare(host, port)
+            o
+        end
+        attr_reader :result, :complete
+        attr_accessor :timeout, :useragent, :tfactory, :client_queue
+        def prepare host, port
+            init
+            @host = host
+            @port = port
+            @on_failure = nil
+            @on_success = nil
+            @on_finish = []
+            @client_queue = nil
+            _this = self
+            @queue = BaseHandler::get_handler('TaskQueue')
+            @method_handle_response = method(:handle_response)
+            #以下のバグへの対応
+            #http://redmine.ruby-lang.org/issues/show/3786
+            @method_timeout = lambda{
+                _this.handle_timeout
+            }
+            #@method_timeout = method(:timeout)
+            #@method_call_on_success = method(:call_on_success)
+            #@method_call_on_failure = method(:call_on_failure)
+        end
+        def timeout= timeout
+            @timeout = timeout
+        end
+        def set_headers header
+            @headers = header
+        end
+        def set_header key, value
+            @headers[key] = value
+        end
+        def request_send methods, path, body = nil
+            @busy = true
+            #puts "req: #{object_id}"
+            if body
+                options = {
+                    :head => @headers,
+                    :body => body
+                }
+                @headers['content-type'] = 'application/x-www-form-urlencoded'
+            else
+                options = {
+                    :head => @headers,
+                }
+            end
+            @timer = @tfactory.get
+            @timer.on_timer(&@method_timeout)
+            @exception = nil
+            begin
+                request(methods, path, options)
+            rescue
+                on_error("x")
+            end
+        end
+        def handle_timeout
+            @exception = TimeoutError::new('timeout')
+            self.on_error
+        end
+        def set_callback on_success, on_failure
+            @on_success = on_success
+            @on_failure = on_failure
+        end
+        def has_callback
+            !@on_success.nil? and !@on_failure.nil?
+        end
+        def set_on_finish on_finish
+            @on_finish << on_finish
+        end
+        def on_finish
+            unless @on_finish.empty?
+                @on_finish.shift.call
+            end
+        end
+        def on_error(reason='error')
+            $REQUEST_COUNT += 1
+            super
+            @tfactory.collect(@timer) if @timer
+            @timer = nil
+            @busy = false
+            @response = @response_object
+            @response.time = @response_time
+            @on_failure.call(@exception, @response) if @on_failure
+            @exception = nil
+        end
+        def send_request_header
+            #無駄な処理を省くため上書き
+            head    = @options[:head]
+            body    = @options[:body]
+
+            # Set the Content-Length if it hasn't been specified already and a body was given
+            # Default to Connection: close
+
+            # Build the request
+            request_header = HTTP_REQUEST_HEADER % [@method, @path]
+            request_header << encode_field('Content-Length', (body ? body.length : 0)) << encode_field('Connection', 'close')
+            for k, v in head
+                request_header << encode_field(k, v)
+            end
+            request_header << CRLF
+            write request_header
+        end
+        def handle_response
+            @tfactory.collect(@timer)
+            @client_queue.collect(self)
+            #@timer = nil
+            @queue.add([@on_success, [self.to_response_object]])
+            #@busy = false
+        end
+        def on_request_complete
+            super
+            return if @exception
+            $REQUEST_COUNT += 1
+            @tfactory.collect(@timer)
+            @client_queue.collect(self)
+            @queue.add([@on_success, [self.to_response_object]])
+            #handle_response
+            #@queue.add([@method_handle_response, ])
+        end
+    end
+end

data/lib/internethakai/hakairev/monkey.rb

@@ -0,0 +1,70 @@
+#rev向きモンキーパッチ
+module Rev
+  class TCPSocket
+      def self.connect(addr, port, *args)
+          #DNS解決済み。ip v4しかこないことを前提する
+          family = ::Socket::AF_INET
+          return super(TCPConnectSocket.new(family, addr, port), *args) # this creates a 'real' write buffer so we're ok there with regards to already having a write buffer from the get go
+      end
+      class TCPConnectSocket
+          @@_cache = {}
+          def initialize(family, addr, port, host = addr)
+              #バグがあったので上書き
+              @host, @addr, @port = host, addr, port
+              @address_family = nil
+
+              @socket = super(family, ::Socket::SOCK_STREAM, 0)
+              begin
+                  key = port.to_s + addr
+                  if @@_cache[key]
+                      addrin = @@_cache[key]
+                  else
+                      addrin = @@_cache[key] = ::Socket.sockaddr_in(port, addr)
+                  end
+                  @socket.connect_nonblock(addrin)
+              rescue Errno::EINPROGRESS
+              end
+          end
+      end
+  end
+  class HttpClient
+    def on_connect
+      @connected = true
+      send_request if @method and @path
+    end
+    def failedtrue
+    end
+  end
+  class Socket
+      def connectornil
+          @_connector = nil
+      end
+  end
+  class Socket::Connector
+      def on_writable
+          evl = evloop
+          detach
+
+          if connect_successful?
+              #@rev_socket.instance_eval { @_connector = nil }
+              @rev_socket.connectornil
+              @rev_socket.attach(evl)
+              @ruby_socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, [1].pack("l"))
+              @ruby_socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+
+              @rev_socket.on_connect
+          else
+              #@rev_socket.instance_eval { @_failed = true }
+              @rev_socket.failedtrue
+              @rev_socket.on_connect_failed
+          end
+      end
+  end
+  class IO
+  end
+  class IO::Watcher
+      #__send__は重い
+      def on_readable; @rev_io.on_readable; end
+      def on_writable; @rev_io.on_writable; end
+  end
+end

data/lib/internethakai/hakairev/revpipe.rb

@@ -0,0 +1,39 @@
+module InternetHakai
+    class RevPipe
+        extend Rev::Meta
+        def initialize
+            r, w = ::IO::pipe
+            @reader = RWatcher::new(r)
+            @writer = Rev::IO::new(w)
+        end
+        attr_reader :reader
+        def attach(loop)
+            @loop = loop
+            @reader.attach(@loop) unless @reader.attached?
+            @writer.attach(@loop) unless @writer.attached?
+        end
+        def write(data)
+            @writer.write(data)
+        end
+        def on_read &block
+            @reader.on_read(&block)
+        end
+    end
+    class RWatcher < Rev::IOWatcher
+        extend Rev::Meta
+        def initialize r
+            @reader = r
+            super(r)
+        end
+        def on_read(data); end
+        event_callback :on_read
+        def on_readable
+            begin
+                on_read(@reader.read_nonblock(Rev::IO::INPUT_SIZE))
+            rescue Errno::EAGAIN
+                # in case there are spurious wakeups from forked processs
+                return
+            end
+        end
+    end
+end