spider-gazelle 1.2.0 → 2.0.0

data/lib/spider-gazelle/spider/binding.rb

@@ -0,0 +1,80 @@
+require 'thread'
+
+module SpiderGazelle
+    class Spider
+        class Binding
+            attr_reader :app_id
+            attr_accessor :tcp
+
+
+            def initialize(iterator, app_id, options)
+                if options[:mode] == :no_ipc
+                    @delegate = method(:direct_delegate)
+                    @gazelle = iterator
+                else
+                    @delegate = method(:delegate)
+                    @select_gazelle = iterator
+                end
+
+                @options = options
+
+                @logger = Logger.instance
+                @signaller = Signaller.instance
+                @thread = @signaller.thread
+
+                @port = @options[:port]
+                @indicator = app_id.to_s.freeze
+            end
+
+            # Bind the application to the selected port
+            def bind
+                # Bind the socket
+                @tcp = @thread.tcp
+                @tcp.bind @options[:host], @port, @delegate
+                @tcp.listen @options[:backlog]
+                @tcp.enable_simultaneous_accepts
+
+                @logger.info "Listening on tcp://#{@options[:host]}:#{@port}"
+
+                @tcp.catch do |error|
+                    begin
+                        @logger.print_error(error)
+                    rescue
+                    ensure
+                        @signaller.general_failure
+                    end
+                end
+                @tcp
+            end
+
+            # Close the bindings
+            def unbind
+                @tcp.close unless @tcp.nil?
+                @tcp
+            end
+
+
+            protected
+
+
+            DELEGATE_ERR = proc { |error|
+                client.close
+                begin
+                    Logger.instance.print_error(error, "delegating socket to gazelle")
+                rescue
+                end
+            }
+            def delegate(client, retries = 0)
+                promise = @select_gazelle.next.write2(client, @indicator)
+                promise.then do
+                    client.close
+                end
+                promise.catch DELEGATE_ERR
+            end
+
+            def direct_delegate(client)
+                @gazelle.__send__(:process_connection, client, @indicator)
+            end
+        end
+    end
+end

data/lib/spider-gazelle/upgrades/websocket.rb

@@ -1,94 +1,98 @@
-require 'spider-gazelle/const'
 require 'websocket/driver'
 require 'forwardable'
 
 module SpiderGazelle
-  class Websocket < ::Libuv::Q::DeferredPromise
-    include Const
-
-    attr_reader :env, :url, :loop
-
-    extend Forwardable
-    def_delegators :@driver, :start, :ping, :protocol, :ready_state, :set_header, :state, :close
-    def_delegators :@socket, :write
-
-    def initialize(tcp, env)
-      @socket, @env = tcp, env
-
-      # Initialise the promise
-      super @socket.loop, @socket.loop.defer
-
-      scheme = env[RACK_URL_SCHEME] == HTTPS ? 'wss://' : 'ws://'
-      @url = scheme + env[HTTP_HOST] + env[REQUEST_URI]
-      @driver = ::WebSocket::Driver.rack self
-
-      # Pass data from the socket to the driver
-      @socket.progress &method(:socket_read)
-      @socket.finally &method(:socket_close)
-
-
-      # Driver has indicated that it is closing
-      # We'll close the socket after writing any remaining data
-      @driver.on :close, &method(:on_close)
-      @driver.on :message, &method(:on_message)
-      @driver.on :error, &method(:on_error)
-    end
-
-    # Write some text to the websocket connection
-    #
-    # @param string [String] a string of data to be sent to the far end
-    def text(string)
-      @loop.schedule { @driver.text(string.to_s) }
-    end
-
-    # Write some binary data to the websocket connection
-    #
-    # @param array [Array] an array of bytes to be sent to the far end
-    def binary(array)
-      @loop.schedule { @driver.binary(array.to_a) }
-    end
-
-    # Used to define a callback when data is received from the client
-    #
-    # @param callback [Proc] the callback to be called when data is received
-    def progress(callback = nil, &blk)
-      @progress = callback || blk
-    end
-
-    # Used to define a callback when the websocket connection is established
-    # Data sent before this callback is buffered.
-    #
-    # @param callback [Proc] the callback to be triggered on establishment
-    def on_open(callback = nil, &blk)
-      callback ||= blk
-      @driver.on :open, &callback
-    end
-
-    protected
-
-    def socket_read(data, tcp)
-      @driver.parse data
-    end
-
-    def socket_close
-      if @shutdown_called.nil?
-        @defer.reject WebSocket::Driver::CloseEvent.new(1006, 'connection was closed unexpectedly')
-      end
-    end
-
-
-    def on_message(event)
-      @progress.call(event.data, self) unless @progress.nil?
-    end
-
-    def on_error(event)
-      @defer.reject event
-    end
-
-    def on_close(event)
-      @shutdown_called = true
-      @socket.shutdown
-      @defer.resolve event
+    class Websocket < ::Libuv::Q::DeferredPromise
+        attr_reader :env, :url, :loop
+
+
+        RACK_URL_SCHEME = "rack.url_scheme".freeze
+        HTTP_HOST = "HTTP_HOST".freeze
+        REQUEST_URI= "REQUEST_URI".freeze
+        HTTPS = 'https'.freeze
+
+
+        extend Forwardable
+        def_delegators :@driver, :start, :ping, :protocol, :ready_state, :set_header, :state, :close
+        def_delegators :@socket, :write
+
+        def initialize(tcp, env)
+            @socket, @env = tcp, env
+
+            # Initialise the promise
+            super tcp.loop, tcp.loop.defer
+
+            scheme = env[RACK_URL_SCHEME] == HTTPS ? 'wss://' : 'ws://'
+            @url = scheme + env[HTTP_HOST] + env[REQUEST_URI]
+            @driver = ::WebSocket::Driver.rack self
+
+            # Pass data from the socket to the driver
+            @socket.progress &method(:socket_read)
+            @socket.finally &method(:socket_close)
+
+
+            # Driver has indicated that it is closing
+            # We'll close the socket after writing any remaining data
+            @driver.on :close, &method(:on_close)
+            @driver.on :message, &method(:on_message)
+            @driver.on :error, &method(:on_error)
+        end
+
+        # Write some text to the websocket connection
+        #
+        # @param string [String] a string of data to be sent to the far end
+        def text(string)
+            @loop.schedule { @driver.text(string.to_s) }
+        end
+
+        # Write some binary data to the websocket connection
+        #
+        # @param array [Array] an array of bytes to be sent to the far end
+        def binary(array)
+            @loop.schedule { @driver.binary(array.to_a) }
+        end
+
+        # Used to define a callback when data is received from the client
+        #
+        # @param callback [Proc] the callback to be called when data is received
+        def progress(callback = nil, &blk)
+            @progress = callback || blk
+        end
+
+        # Used to define a callback when the websocket connection is established
+        # Data sent before this callback is buffered.
+        #
+        # @param callback [Proc] the callback to be triggered on establishment
+        def on_open(callback = nil, &blk)
+            callback ||= blk
+            @driver.on :open, &callback
+        end
+
+        protected
+
+        def socket_read(data, tcp)
+            @driver.parse data
+        end
+
+        def socket_close
+            if @shutdown_called.nil?
+                @defer.reject WebSocket::Driver::CloseEvent.new(1006, 'connection was closed unexpectedly')
+            end
+        end
+
+
+        def on_message(event)
+            @progress.call(event.data, self) unless @progress.nil?
+        end
+
+        def on_error(event)
+            @defer.reject event
+        end
+
+        def on_close(event)
+            @shutdown_called = true
+            @socket.shutdown
+            @defer.resolve event
+        end
     end
-  end
 end

data/spec/http1_spec.rb

@@ -0,0 +1,173 @@
+require 'spider-gazelle/gazelle/http1'
+
+
+# TODO:: Mock logger
+
+class MockSocket
+    def initialize
+        @stopped = false
+        @write_cb = proc {}
+    end
+
+    attr_reader   :closed, :stopped
+    attr_accessor :storage, :write_cb, :shutdown_cb, :close_cb
+
+    def peername; ['127.0.0.1']; end
+    def finally(method = nil, &block); @on_close = method || block; end
+    def close; @close_cb.call; end
+    def shutdown; @shutdown_cb.call; end
+    def progress(_); end
+    def stop_read; @stopped = true; end
+
+    def write(data); @write_cb.call(data); end
+end
+
+class MockLogger
+    def initialize
+        @logged = []
+    end
+
+    attr_reader :logged
+
+    def method_missing(methId, *args)
+        @logged << methId
+        p "methId: #{args}"
+    end
+end
+
+describe ::SpiderGazelle::Gazelle::Http1 do
+    before :each do
+        @shutdown_called = 0
+        @close_called = 0
+
+        @loop = ::Libuv::Loop.default
+        @timeout = @loop.timer do
+            @loop.stop
+            @general_failure << "test timed out"
+        end
+        @timeout.start(1000)
+
+
+        @return ||= proc {|http1|
+            @returned = http1
+        }
+        @logger = MockLogger.new
+        @http1_callbacks ||= ::SpiderGazelle::Gazelle::Http1::Callbacks.new
+        @http1 = ::SpiderGazelle::Gazelle::Http1.new(@return, @http1_callbacks, @loop, @logger)
+
+        @socket = MockSocket.new
+        @socket.shutdown_cb = proc {
+            @shutdown_called += 1
+            @loop.stop
+        }
+        @socket.close_cb = proc {
+            @close_called += 1
+            @loop.stop
+        }
+
+        @app_mode = :thread_pool
+        @port = 80
+        @tls = false
+    end
+
+    after :each do
+        @timeout.close
+    end
+
+    it "should process a single request and close the connection", http1: true do
+        app = lambda do |env|
+            body = 'Hello, World!'
+            [200, {'Content-Type' => 'text/plain', 'Content-Length' => body.length.to_s}, [body]]
+        end
+        writes = []
+
+        @loop.run {
+            @http1.load(@socket, @port, app, @app_mode, @tls)
+            @http1.parse("GET / HTTP/1.1\r\nConnection: Close\r\n\r\n")
+
+            @socket.write_cb = proc { |data|
+                writes << data
+            }
+        }
+
+        expect(@shutdown_called).to be == 1
+        expect(@close_called).to be == 0
+        expect(writes).to eq([
+            "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 13\r\nConnection: close\r\n\r\n",
+            "Hello, World!"
+        ])
+    end
+
+    it "should process a single request and keep the connection open", http1: true do
+        app = lambda do |env|
+            body = 'Hello, World!'
+            [200, {'Content-Type' => 'text/plain', 'Content-Length' => body.length.to_s}, [body]]
+        end
+        writes = []
+
+        @loop.run {
+            @http1.load(@socket, @port, app, @app_mode, @tls)
+            @http1.parse("GET / HTTP/1.1\r\n\r\n")
+
+            @socket.write_cb = proc { |data|
+                writes << data
+                if writes.length == 2
+                    @loop.next_tick do
+                        @loop.stop
+                    end
+                end
+            }
+        }
+
+        expect(@shutdown_called).to be == 0
+        expect(@close_called).to be == 0
+        expect(writes).to eq([
+            "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 13\r\n\r\n",
+            "Hello, World!"
+        ])
+    end
+
+    it "should fill out the environment properly", http1: true do
+        app = lambda do |env|
+            expect(env['REQUEST_URI']).to eq('/?test=ing')
+            expect(env['REQUEST_PATH']).to eq('/')
+            expect(env['QUERY_STRING']).to eq('test=ing')
+            expect(env['SERVER_NAME']).to eq('spider.gazelle.net')
+            expect(env['SERVER_PORT']).to eq(80)
+            expect(env['REMOTE_ADDR']).to eq('127.0.0.1')
+            expect(env['rack.url_scheme']).to eq('http')
+
+            body = 'Hello, World!'
+            [200, {'Content-Type' => 'text/plain', 'Content-Length' => body.length.to_s}, [body]]
+        end
+
+        @loop.run {
+            @http1.load(@socket, @port, app, @app_mode, @tls)
+            @http1.parse("GET /?test=ing HTTP/1.1\r\nHost: spider.gazelle.net\r\nConnection: Close\r\n\r\n")
+        }
+
+        expect(@shutdown_called).to be == 1
+        expect(@close_called).to be == 0
+    end
+
+    it "should respond with a chunked response", http1: true do
+        app = lambda do |env|
+            body = ['Hello', ',', ' World!']
+            [200, {'Content-Type' => 'text/plain'}, body]
+        end
+        writes = []
+
+        @loop.run {
+            @http1.load(@socket, @port, app, @app_mode, @tls)
+            @http1.parse("GET / HTTP/1.1\r\nConnection: Close\r\n\r\n")
+
+            @socket.write_cb = proc { |data|
+                writes << data
+            }
+        }
+
+        expect(@shutdown_called).to be == 1
+        expect(@close_called).to be == 0
+        expect(writes).to eq(["HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n", "5\r\nHello\r\n", "1\r\n,\r\n", "7\r\n World!\r\n", "0\r\n\r\n"])
+    end
+end

data/spec/rack_lock_spec.rb

@@ -6,121 +6,121 @@ require 'rack/lock_patch'
 
 
 module Rack
-  class Lock
-    def would_block
-      @count > 0
+    class Lock
+        def would_block
+            @count > 0
+        end
     end
-  end
 end
 
 
-  def lock_app(app)
+def lock_app(app)
     app = Rack::Lock.new(app)
     return app, Rack::Lint.new(app)
-  end
+end
 
 
 describe Rack::Lock do
 
-  describe 'Proxy' do
-
-    it 'delegate each' do
-      env      = Rack::MockRequest.env_for("/")
-      response = Class.new {
-        attr_accessor :close_called
-        def initialize; @close_called = false; end
-        def each; %w{ hi mom }.each { |x| yield x }; end
-      }.new
-
-      app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })[1]
-      response = app.call(env)[2]
-      list = []
-      response.each { |x| list << x }
-      expect(list).to eq(%w{ hi mom })
-    end
+    describe 'Proxy' do
+
+        it 'delegate each' do
+            env      = Rack::MockRequest.env_for("/")
+            response = Class.new {
+                attr_accessor :close_called
+                def initialize; @close_called = false; end
+                def each; %w{ hi mom }.each { |x| yield x }; end
+            }.new
+
+            app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })[1]
+            response = app.call(env)[2]
+            list = []
+            response.each { |x| list << x }
+            expect(list).to eq(%w{ hi mom })
+        end
+
+        it 'delegate to_path' do
+            env  = Rack::MockRequest.env_for("/")
 
-    it 'delegate to_path' do
-      env  = Rack::MockRequest.env_for("/")
+            res = ['Hello World']
+            def res.to_path ; "/tmp/hello.txt" ; end
 
-      res = ['Hello World']
-      def res.to_path ; "/tmp/hello.txt" ; end
+            app = Rack::Lock.new(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] })
+            body = app.call(env)[2]
 
-      app = Rack::Lock.new(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] })
-      body = app.call(env)[2]
+            expect(body.respond_to? :to_path).to eq(true)
+            expect(body.to_path).to eq("/tmp/hello.txt")
+        end
 
-      expect(body.respond_to? :to_path).to eq(true)
-      expect(body.to_path).to eq("/tmp/hello.txt")
+        it 'not delegate to_path if body does not implement it' do
+            env  = Rack::MockRequest.env_for("/")
+
+            res = ['Hello World']
+
+            app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] })[1]
+            body = app.call(env)[2]
+
+            expect(body.respond_to? :to_path).to eq(false)
+        end
     end
 
-    it 'not delegate to_path if body does not implement it' do
-      env  = Rack::MockRequest.env_for("/")
+    it 'call super on close' do
+        env      = Rack::MockRequest.env_for("/")
+        response = Class.new {
+            attr_accessor :close_called
+            def initialize; @close_called = false; end
+            def close; @close_called = true; end
+        }.new
+
+        app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })[1]
+        app.call(env)
+        expect(response.close_called).to eq(false)
+        response.close
+        expect(response.close_called).to eq(true)
+    end
 
-      res = ['Hello World']
+    it "not unlock until body is closed" do
+        env      = Rack::MockRequest.env_for("/")
+        response = Object.new
+        lock, app      = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
 
-      app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] })[1]
-      body = app.call(env)[2]
+        expect(lock.would_block).to eq(false)
+        response = app.call(env)[2]
+        expect(lock.would_block).to eq(true)
+        response.close
+        expect(lock.would_block).to eq(false)
+    end
+
+    it "return value from app" do
+        env  = Rack::MockRequest.env_for("/")
+        body = [200, {"Content-Type" => "text/plain"}, %w{ hi mom }]
+        app  = lock_app(lambda { |inner_env| body })[1]
+
+        res = app.call(env)
+        expect(res[0]).to eq(body[0])
+        expect(res[1]).to eq(body[1])
+        expect(res[2].to_enum.to_a).to eq(["hi", "mom"])
+    end
+
+    it "call synchronize on lock" do
+        env = Rack::MockRequest.env_for("/")
+        lock, app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, %w{ a b c }] })
+        expect(lock.would_block).to eq(false)
+        app.call(env)
+        expect(lock.would_block).to eq(true)
+    end
+
+    it "unlock if the app raises" do
+        env = Rack::MockRequest.env_for("/")
+        lock, app = lock_app(lambda { raise Exception })
+        expect { app.call(env) }.to raise_error(Exception)
+        expect(lock.would_block).to eq(false)
+    end
 
-      expect(body.respond_to? :to_path).to eq(false)
+    it "unlock if the app throws" do
+        env = Rack::MockRequest.env_for("/")
+        lock, app = lock_app(lambda {|_| throw :bacon })
+        expect { app.call(env) }.to raise_error(ArgumentError)
+        expect(lock.would_block).to eq(false)
     end
-  end
-
-  it 'call super on close' do
-    env      = Rack::MockRequest.env_for("/")
-    response = Class.new {
-      attr_accessor :close_called
-      def initialize; @close_called = false; end
-      def close; @close_called = true; end
-    }.new
-
-    app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })[1]
-    app.call(env)
-    expect(response.close_called).to eq(false)
-    response.close
-    expect(response.close_called).to eq(true)
-  end
-
-  it "not unlock until body is closed" do
-    env      = Rack::MockRequest.env_for("/")
-    response = Object.new
-    lock, app      = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
-
-    expect(lock.would_block).to eq(false)
-    response = app.call(env)[2]
-    expect(lock.would_block).to eq(true)
-    response.close
-    expect(lock.would_block).to eq(false)
-  end
-
-  it "return value from app" do
-    env  = Rack::MockRequest.env_for("/")
-    body = [200, {"Content-Type" => "text/plain"}, %w{ hi mom }]
-    app  = lock_app(lambda { |inner_env| body })[1]
-
-    res = app.call(env)
-    expect(res[0]).to eq(body[0])
-    expect(res[1]).to eq(body[1])
-    expect(res[2].to_enum.to_a).to eq(["hi", "mom"])
-  end
-
-  it "call synchronize on lock" do
-    env = Rack::MockRequest.env_for("/")
-    lock, app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, %w{ a b c }] })
-    expect(lock.would_block).to eq(false)
-    app.call(env)
-    expect(lock.would_block).to eq(true)
-  end
-
-  it "unlock if the app raises" do
-    env = Rack::MockRequest.env_for("/")
-    lock, app = lock_app(lambda { raise Exception })
-    expect { app.call(env) }.to raise_error(Exception)
-    expect(lock.would_block).to eq(false)
-  end
-
-  it "unlock if the app throws" do
-    env = Rack::MockRequest.env_for("/")
-    lock, app = lock_app(lambda {|_| throw :bacon })
-    expect { app.call(env) }.to raise_error(ArgumentError)
-    expect(lock.would_block).to eq(false)
-  end
 end