spiderfw 0.5

data/lib/spiderfw/http/adapters/mongrel.rb

@@ -0,0 +1,207 @@
+require 'mongrel'
+
+module Spider; module HTTP
+    
+    class Mongrel < Server
+        
+        @supports = {
+            :chunked_request => false
+        }
+        
+        def start_server(opts={})
+            opts = options(opts)
+            @server = ::Mongrel::HttpServer.new(opts[:host], opts[:port])
+            if (opts[:cgi]) 
+                @server.register("/", MongrelCGIServlet.new(self))
+            else 
+                @server.register("/", MongrelServlet.new(self))
+            end
+            info_string = "Starting Mongrel on #{opts[:host]}:#{opts[:port]}"
+            info_string += " (CGI mode)" if opts[:cgi]
+            Spider.logger.info(info_string)
+            @server.run.join
+        end
+        
+        
+        def shutdown_server
+            @server.stop
+        end
+        
+        
+    end
+    
+    class MongrelIO < ControllerIO
+        
+        def initialize(response, controller_response)
+            @response = response
+            @controller_response = controller_response
+        end
+        
+        def write(msg)
+            unless @response.header_sent
+                #Spider::Logger.debug("Sending headers because wrote #{msg}")
+                send_headers
+            end
+            @response.write(msg) rescue Errno::EPIPE # FIXME: is it bad?
+        end
+        
+        def self.send_headers(controller_response, response)
+            controller_response.prepare_headers
+            response.status = controller_response.status
+            response.send_status(nil)
+            controller_response.headers.each do |key, val|
+                if (val.is_a?(Array))
+                    val.each{ |v| response.header[key] = v }
+                else
+                    response.header[key] = val
+                end
+            end
+            response.send_header
+        end
+        
+        def send_headers
+            Spider::Logger.debug("---SENDING HEADERS----")
+            
+            self.class.send_headers(@controller_response, @response)
+
+            
+        end
+        
+        
+        def flush
+        end
+        
+    end
+    
+    
+    class MongrelServlet < ::Mongrel::HttpHandler
+        
+        def initialize(server)
+            @server = server
+            #@request_notify = true
+        end
+        
+        def request_begins(params)
+            Spider.logger.debug( "REQUEST BEGINS:")
+            Spider.logger.debug(params)
+        end
+        
+        def request_progress(params, clen, total)
+            Spider.logger.debug("REQUEST_PROGRESS")
+            Spider.logger.debug(params)
+            Spider.logger.debug(clen)
+            Spider.logger.debug(total)
+        end
+        
+        def process(request, response)
+            Spider.request_started
+            @server.request_received
+            path = request.params['REQUEST_PATH']
+            env = normalize_request(request.params.clone)
+            controller_request = Spider::Request.new(env)
+            controller_request.server = Mongrel
+            controller_request.body = request.body
+            controller_request.action = path
+            controller_request.request_time = Time.now
+
+            controller_response = Spider::Response.new
+            if (Spider.conf.get('http.auto_headers'))
+                Spider::Logger.debug("ENABLING AUTO HEADERS: #{Spider.conf.get('http.auto_headers')}")
+                controller_response.server_output = MongrelIO.new(response, controller_response)
+            else
+                controller_response.server_output = response
+            end
+
+            begin
+                controller = ::Spider::HTTPController.new(controller_request, controller_response)
+                controller.extend(Spider::FirstResponder)
+                Spider::Logger.debug("CONTROLLER: #{controller}")
+                controller.before(path)
+                MongrelIO.send_headers(controller_response, response) unless Spider.conf.get('http.auto_headers')
+                controller.execute(path)
+                Spider::Logger.debug("Response:")
+                Spider::Logger.debug(controller.response)
+                controller.after(path)
+                Spider::Logger.debug("Controller #{controller} DONE")
+            rescue => exc
+                Spider.logger.error(exc)
+                controller.ensure() if controller
+            ensure
+                MongrelIO.send_headers(controller_response, response) unless response.header_sent
+                Spider::Logger.debug("---- Closing Mongrel Response ---- ")
+                response.finished
+                Spider.request_finished
+            end
+            
+            
+        end
+        
+        
+        def normalize_request(params)
+            return params
+        end
+        
+    end
+    
+    class MongrelCGIServlet < ::Mongrel::HttpHandler
+        
+        def initialize(server)
+            @server = server
+        end
+        
+        def process(request, response)
+            
+            ENV['SPIDER_PATH'] = $SPIDER_PATH
+            ['SERVER_NAME', 'PATH_INFO', 'HTTP_ACCEPT_ENCODING', 'HTTP_USER_AGENT', 'SCRIPT_NAME',
+             'SERVER_PROTOCOL', 'HTTP_COOKIE', 'HTTP_HOST', 'HTTP_ACCEPT_LANGUAGE', 'SERVER_SOFTWARE', 'REQUEST_PATH',
+             'HTTP_VERSION', 'REQUEST_URI', 'SERVER_PORT', 'GATEWAY_INTERFACE', 'HTTP_ACCEPT', 'HTTP_CONNECTION',
+             'REQUEST_METHOD', 'QUERY_STRING', 'CONTENT_TYPE', 'CONTENT_LENGTH'].each do |key|
+                ENV[key] = request.params[key]
+            end
+            io = IO.popen("ruby "+$SPIDER_PATH+"/lib/spiderfw/http/adapters/cgi.rb", 'r+')
+            
+            while (request.body.gets)
+                io.write($_)
+            end
+            headers_sent = false
+            while(io.gets)
+                if !response.header_sent
+                    if ($_ == "\n")
+                        unless response.status_sent
+                            response.status = 200
+                            response.send_status(nil)
+                        end
+                        response.send_header 
+                    else
+                        parse_header($_, response)
+                    end
+                else
+                    response.write($_)
+                end
+            end
+            io.close
+            response.finished
+        
+        end
+        
+        def parse_header(str, response)
+            Spider.logger.debug("HEADER #{str}")
+            key, val = str.split(':', 2)
+            return unless key
+            key.strip!
+            val.strip! if val
+            if (val)
+                if (key == 'Status')
+                    response.status = val
+                    response.send_status(nil)
+                end
+                response.header[key] = val
+            elsif(str =~ /^(\d+)\s*/)
+                response.status = $1
+                response.send_status(nil)
+            end 
+        end
+        
+    end
+    
+end; end

data/lib/spiderfw/http/adapters/rack.rb

@@ -0,0 +1,152 @@
+require 'spiderfw/controller/request'
+require 'spiderfw/controller/http_controller'
+
+module Spider; module HTTP
+    
+    class RackRequest < Spider::Request
+        attr_accessor :rack_input
+        
+        
+        def body(&proc)
+            @rack_input.each{ |buf| yield buf }
+        end
+        
+        
+    end
+    
+    class RackIO < ControllerIO
+
+        def initialize(response, controller_response, w)
+            @response = response
+            @controller_response = controller_response
+            @w = w
+            @headers_sent = false
+            @rack_thread = Thread.current
+        end
+
+        def write(msg)
+            send_headers unless @headers_sent
+            @w.write(msg)
+        end
+
+        def send_headers
+            Spider::Logger.debug("---SENDING HEADERS----")
+            @controller_response.prepare_headers
+            @response[:status] = @controller_response.status
+            @response[:headers] = {}
+            @controller_response.headers.each do |key, val|
+                if (val.is_a?(Array))
+                    val.each{ |v| @response[:headers][key] = v.to_s }
+                else
+                    @response[:headers][key] = val.to_s
+                end
+            end
+            @headers_sent = true
+            @rack_thread.run if Spider.conf.get('webserver.force_threads')
+        end
+
+        def headers_sent?
+            @headers_sent
+        end
+        
+        def set_body_io(io)
+            return super if headers_sent?
+            @response.body = io
+            send_headers
+        end
+
+
+        def flush
+        end
+
+    end
+    
+    class RackApplication
+
+        def call(env)
+            Spider.request_started
+            env = prepare_env(env)
+            controller_request = RackRequest.new(env)
+            controller_request.server = RackApplication
+            controller_request.rack_input = env['rack.input']
+            path = env['PATH_INFO'].chomp('/')
+            controller_request.action = path
+            controller_request.request_time = DateTime.now
+
+            controller_response = Spider::Response.new
+            if (Spider.conf.get('webserver.force_threads'))
+                r, w = IO.pipe
+                rack_response_hash = {:body => r}
+                controller_response.server_output = RackIO.new(rack_response_hash, controller_response, w)
+            else
+                w = StringIO.new
+                controller_response.server_output = w
+                rack_response_hash = {:body => w}
+            end
+
+
+            controller_done = false
+
+            run_block = lambda do
+                begin
+                    controller = ::Spider::HTTPController.new(controller_request, controller_response)
+                    controller.extend(Spider::FirstResponder)
+                    controller.before(path)
+                    controller.execute(path)
+                    controller.after(path)
+                    Spider::Logger.debug("Controller done")
+                rescue => exc
+                    Spider.logger.debug("Error:")
+                    Spider.logger.debug(exc)
+                    controller.ensure() if controller
+                ensure
+                    if (Spider.conf.get('webserver.force_threads'))
+                        controller_response.server_output.send_headers unless controller_response.server_output.headers_sent?
+                    else
+                        controller_response.prepare_headers
+                        rack_response_hash[:status] = controller_response.status
+                        rack_response_hash[:headers] = {}
+                        controller_response.headers.each do |key, val|
+                            if (val.is_a?(Array))
+                                val.each{ |v| rack_response_hash[:headers][key] = v.to_s }
+                            else
+                                rack_response_hash[:headers][key] = val.to_s
+                            end
+                        end
+                        w.rewind
+                    end
+                    controller_done = true
+                    Spider.request_finished
+                end
+            end
+            
+            controllerThread = Thread.start &run_block
+            if (Spider.conf.get('webserver.force_threads'))
+                while (!controller_done && !controller_response.server_output.headers_sent?)
+                    Thread.stop
+                end
+            else
+                controllerThread.join
+            end
+
+            Spider.logger.debug("Rack responding")
+            return [rack_response_hash[:status], rack_response_hash[:headers], rack_response_hash[:body]]
+        end
+        
+        def prepare_env(env)
+            env['HTTP_CONTENT_TYPE'] = env['CONTENT_TYPE']
+            return env
+        end
+        
+        def initialize_server
+            Spider.startup
+        end
+        
+        def finalize_server
+            Spider.shutdown
+        end
+        
+    end
+    
+end; end
+    

data/lib/spiderfw/http/adapters/thin.rb

@@ -0,0 +1,38 @@
+require 'thin'
+require 'spiderfw/http/adapters/rack'
+
+module Spider; module HTTP
+    
+    class Thin < Server
+        
+        @supports = {
+            :chunked_request => false
+        }
+
+        def options(opts)
+            opts = super(opts)
+            defaults = {
+                :host   => 'localhost',
+                :app    => 'spider'
+            }
+            return defaults.merge(opts)
+        end
+
+
+        def start_server(opts={})
+            opts = options(opts)
+            options = {
+                :Port           => opts[:port],
+                :BindAddress    => opts[:host]
+            }
+            @server = ::Thin::Server.start(opts[:host], opts[:port].to_i, Spider::HTTP::RackApplication.new)
+        end
+
+        def shutdown_server
+            @server.stop
+        end
+        
+    end
+    
+    
+end; end

data/lib/spiderfw/http/adapters/webrick.rb

@@ -0,0 +1,176 @@
+require 'webrick'
+require 'stringio'
+
+module Spider; module HTTP
+
+    class WEBrick < Server
+
+        @supports = {
+            :chunked_request => true,
+            :ssl => true
+        }
+
+        def options(opts)
+            opts = super(opts)
+            defaults = {
+                :host   => 'localhost',
+                :app    => 'spider'
+            }
+            return defaults.merge(opts)
+        end
+
+
+        def start_server(opts={})
+            opts = options(opts)
+            options = {
+                :Port           => opts[:port],
+                :BindAddress    => opts[:host]
+            }
+            if (opts[:ssl])
+                require 'webrick/https'
+                require 'openssl'
+                options[:SSLEnable] = true
+                options[:SSLVerifyClient] = ::OpenSSL::SSL::VERIFY_NONE
+                options[:SSLCertificate] = OpenSSL::X509::Certificate.new(File.open(opts[:ssl_cert]).read)
+                options[:SSLPrivateKey] = OpenSSL::PKey::RSA.new(File.open(opts[:ssl_private_key]).read)
+#                options[:SSLCertName] = [ [ "CN",WEBrick::Utils::getservername ] ]
+            end
+            @server = ::WEBrick::HTTPServer.new(options)
+            @server.mount("/", WEBrickServlet)
+            @server.start
+        end
+
+        def shutdown_server
+            @server.shutdown
+        end
+
+
+    end
+    
+    class WEBrickRequest < Spider::Request
+        attr_accessor :webrick_request
+        
+        
+        def body(&proc)
+            @webrick_request.body{ |buf| yield buf }
+        end
+        
+        
+    end
+    
+    class WEBrickIO < ControllerIO
+
+        def initialize(response, controller_response, w)
+            @response = response
+            @controller_response = controller_response
+            @w = w
+            @headers_sent = false
+            @webrick_thread = Thread.current
+        end
+
+        def write(msg)
+            send_headers unless @headers_sent
+            @w.write(msg)
+        end
+
+        def send_headers
+            Spider::Logger.debug("---SENDING HEADERS----")
+            @controller_response.prepare_headers
+            @response.status = @controller_response.status
+            @controller_response.headers.each do |key, val|
+                if (val.is_a?(Array))
+                    val.each{ |v| @response[key] = v }
+                else
+                    @response[key] = val
+                end
+            end
+            @headers_sent = true
+            @webrick_thread.run if Spider.conf.get('webserver.force_threads')
+        end
+
+        def headers_sent?
+            @headers_sent
+        end
+        
+        def set_body_io(io)
+            return super if headers_sent?
+            @response.body = io
+            send_headers
+        end
+
+
+        def flush
+        end
+
+    end
+
+
+    class WEBrickServlet < ::WEBrick::HTTPServlet::AbstractServlet
+
+        def service(request, response)
+            Spider.request_started
+            env = prepare_env(request)
+            controller_request = WEBrickRequest.new(env)
+            controller_request.server = WEBrick
+            controller_request.webrick_request = request
+            path = request.path.chomp('/')
+            controller_request.action = path || ''
+            controller_request.request_time = request.request_time
+            controller_request.body = request.body
+
+            r, w = IO.pipe
+            response.body = r
+
+            controller_response = Spider::Response.new
+            controller_response.server_output = WEBrickIO.new(response, controller_response, w)
+
+
+            controller_done = false
+
+            run_block = lambda do
+                begin
+                    controller = ::Spider::HTTPController.new(controller_request, controller_response)
+                    controller.extend(Spider::FirstResponder)
+                    controller.before(path)
+                    controller.execute(path)
+                    controller.after(path)
+                    Spider::Logger.debug("Controller done")
+                rescue => exc
+                    Spider.logger.debug("Error:")
+                    Spider.logger.debug(exc)
+                    controller.ensure() if controller
+                ensure
+                    controller_response.server_output.send_headers unless controller_response.server_output.headers_sent?
+                    w.close
+                    controller_done = true
+                    Spider.request_finished
+                end
+            end
+
+            if (Spider.conf.get('webserver.force_threads'))
+                controllerThread = Thread.start &run_block
+                while (!controller_done && !controller_response.server_output.headers_sent?)
+                    Thread.stop
+                end
+            else
+                run_block.call
+            end
+
+            Spider.logger.debug("Webrick responding")
+        end
+
+        def prepare_env(request)
+            # Spider.logger.debug("WEBRICK REQUEST: #{request}")
+            # Spider.logger.debug("METAVARS: #{request.meta_vars}")
+            env = request.meta_vars.clone
+            env['HTTP_CONTENT_TYPE'] = env['CONTENT_TYPE']
+            env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+            env["QUERY_STRING"] ||= ""
+            env["REQUEST_PATH"] ||= env['PATH_INFO']
+            return env
+        end
+
+    end
+
+
+end; end