ptomato-ramaze 2009.02

data/lib/ramaze/adapter/base.rb

@@ -0,0 +1,128 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Adapter
+
+    # (Rack) middleware injected around Adapter::Base::call
+    MIDDLEWARE = OrderedSet[
+      Rack::ShowExceptions,
+      Rack::ShowStatus,
+      # Rack::Deflater,
+      Ramaze::Reloader,
+      Ramaze::Current,
+      Ramaze::Dispatcher
+    ] unless defined? MIDDLEWARE
+
+    def self.middleware(mws = MIDDLEWARE)
+      if @middleware and trait[:previous] == mws
+        @middleware
+      else
+        trait :previous => mws.dup
+        inner_app = mws.last
+        cascade = mws[0...-1].reverse
+
+        @middleware = cascade.inject(inner_app){|app, mw| mw.new(app) }
+      end
+    end
+
+    @middleware = nil
+    @middleware = middleware
+
+    # Helper to assign a new block to before_call
+    # Usage:
+    #   Ramaze::Adapter.before do |env|
+    #     if env['PATH_INFO'] =~ /superfast/
+    #       [200, {'Content-Type' => 'text/plain'}, ['super fast!']]
+    #     end
+    #   end
+
+    def self.before(&block)
+      @before = block if block
+      @before
+    end
+
+    # This class is holding common behaviour for its subclasses.
+
+    class Base
+      class << self
+
+        attr_reader :thread
+
+        # Call ::startup with the given host and port.
+        # Sets Global.server to itself.
+        # Adds a trap that is triggered by the value of Global.shutdown_trap,
+        # which is SIGINT by default.
+
+        def start(host = nil, port = nil)
+          @thread = startup(host, port)
+          Global.server = self
+
+          trap(Global.shutdown_trap){
+            trap(Global.shutdown_trap){ exit!  }
+            exit
+          }
+        end
+
+        # Does nothing by default
+
+        def shutdown
+          if @server.respond_to?(:stop)
+            Log.dev "Stopping @server"
+            @server.stop
+          else
+            Log.dev "Cannot stop @server, skipping this step."
+          end
+        end
+
+        def join
+          @thread.join
+        end
+
+        # Tries to find the block assigned by #before and calls it, logs and
+        # raises again any errors encountered during this process.
+
+        def before_call env
+          if Adapter.before
+            begin
+              Adapter.before.call(env)
+            rescue Object => e
+              Ramaze::Log.error e
+              raise e
+            end
+          end
+        end
+
+        # This is called by Rack with the usual env, subsequently calls
+        # ::respond with it.
+        #
+        # The method itself acts just as a wrapper for benchmarking and then
+        # calls .finish on the current response after ::respond has finished.
+
+        def call(env)
+          if returned = before_call(env)
+            returned
+          elsif Global.benchmarking
+            require 'benchmark'
+            time = Benchmark.measure{ returned = respond(env) }
+            Log.debug('request took %.5fs [~%.0f r/s]' % [time.real, 1.0/time.real])
+            returned
+          else
+            respond(env)
+          end
+        end
+
+        # Initializes Request with env and an empty Response. Records the
+        # request into Ramaze::Record if Global.record is true.
+        # Then goes on and calls Dispatcher::handle with request and response.
+
+        def respond(env)
+          Ramaze::STATE.wrap do
+            Adapter::middleware.call(env)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/cgi.rb

@@ -0,0 +1,20 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  Global.test_connections = false
+
+  module Adapter
+    # Our CGI adapter acts as wrapper for the Rack::Handler::CGI.
+    class Cgi < Base
+
+      # start CGI in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def self.startup(host = nil, port = nil)
+        Global.server=self
+        Thread.new{ Rack::Handler::CGI.run(self) }
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/ebb.rb

@@ -0,0 +1,18 @@
+require 'ebb'
+
+module Ramaze
+  module Adapter
+    class Ebb < Base
+      def self.startup(host, port)
+        ::Ebb.log = StringIO.new
+        Thread.new do
+          ::Ebb.start_server(self, :port => port)
+        end
+      end
+
+      def self.shutdown
+        ::Ebb.stop_server
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/evented_mongrel.rb

@@ -0,0 +1,7 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+Ramaze::Log.debug "Using Evented Mongrel"
+
+require 'swiftcore/evented_mongrel'
+require 'ramaze/adapter/mongrel'

data/lib/ramaze/adapter/fake.rb

@@ -0,0 +1,12 @@
+module Ramaze
+  module Adapter
+    class Fake < Base
+      def self.startup(host = nil, port = nil)
+        Thread.new{ loop{ sleep(1) } }
+      end
+
+      def self.shutdown
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/fcgi.rb

@@ -0,0 +1,18 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  Global.test_connections = false
+
+  module Adapter
+    # Our Fcgi adapter acts as wrapper for the Rack::Handler::FastCGI.
+    class Fcgi < Base
+      # start FastCGI in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def self.startup(host = nil, port = nil)
+        Thread.new{ Rack::Handler::FastCGI.run(self) }
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/lsws.rb

@@ -0,0 +1,19 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  Global.test_connections = false
+
+  module Adapter
+    # Our Lsws adapter acts as wrapper for the Rack::Handler::LSWS.
+    class Lsws < Base
+
+      # start Lsws in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def self.startup(host = nil, port = nil)
+        Thread.new{ Rack::Handler::LSWS.run(self) }
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/mongrel.rb

@@ -0,0 +1,21 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'mongrel'
+require 'rack/handler/mongrel'
+
+module Ramaze
+  module Adapter
+
+    # Our Mongrel adapter acts as wrapper for the Rack::Handler::Mongrel.
+    class Mongrel < Base
+
+      # start server on given host and port.
+      def self.startup(host, port)
+        @server = ::Mongrel::HttpServer.new(host, port)
+        @server.register('/', ::Rack::Handler::Mongrel.new(self))
+        @server.run
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/scgi.rb

@@ -0,0 +1,18 @@
+#          Copyright (c) 2008 Jeremy Evans  code@jeremyevans.net
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'rack/handler/scgi'
+
+module Ramaze
+  module Adapter
+    # Our Scgi adapter acts as wrapper for the Rack::Handler::SCGI.
+    class Scgi < Base
+      # start SCGI in a new thread
+      def self.startup(host, port)
+        Thread.new do
+          Rack::Handler::SCGI.run(self, :Host => host, :Port => port)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/swiftiplied_mongrel.rb

@@ -0,0 +1,7 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+Ramaze::Log.debug "Using Swiftiplied Mongrel"
+
+require 'swiftcore/swiftiplied_mongrel'
+require 'ramaze/adapter/mongrel'

data/lib/ramaze/adapter/thin.rb

@@ -0,0 +1,17 @@
+require 'thin'
+require 'rack/handler/thin'
+
+module Ramaze
+  module Adapter
+    class Thin < Base
+      # start server on given host and port.
+      def self.startup(host, port)
+        @server = ::Thin::Server.new(host, port, self)
+        ::Thin::Logging.silent = true
+        @server.timeout = 3
+
+        Thread.new{ @server.start }
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/webrick.rb

@@ -0,0 +1,43 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'webrick'
+require 'rack/handler/webrick'
+
+module Ramaze
+  module Adapter
+    # Our WEBrick adapter acts as wrapper for the Rack::Handler::WEBrick.
+    class WEBrick < Base
+      OPTIONS = {
+        :Logger      => Log,
+        :AccessLog   => [
+          [Log, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+          [Log, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
+        ]
+      }
+
+      def self.startup(host, port)
+        options = OPTIONS.merge(:BindAddress => host, :Port => port)
+        @server = ::WEBrick::HTTPServer.new(options)
+        @server.mount('/', ::Rack::Handler::WEBrick, self)
+        Thread.new{ @server.start }
+      end
+    end
+  end
+end
+
+# Extending on WEBrick module
+module WEBrick
+
+  # Extending on HTTPServlet
+  module HTTPServlet
+
+    # Extending on ProcHandler
+    #
+    # We alias PUT to GET and DELETE to GET so WEBrick handles them as well.
+    class ProcHandler
+      alias do_PUT do_GET
+      alias do_DELETE do_GET
+    end
+  end
+end

data/lib/ramaze/adapter.rb

@@ -0,0 +1,97 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/trinity'
+require 'ramaze/tool/record'
+require 'ramaze/adapter/base'
+require 'ramaze/adapter/fake'
+
+# for OSX compatibility
+Socket.do_not_reverse_lookup = true
+
+module Ramaze
+
+  # This module holds all classes and methods related to the adapters like
+  # webrick or mongrel.
+  # It's responsible for starting and stopping them.
+
+  module Adapter
+    class << self
+
+      # Is called by Ramaze.startup and will first call start_adapter and wait
+      # up to 3 seconds for an adapter to appear.
+      # It will then wait for the adapters to finish If Global.run_loose is
+      # set or otherwise pass you on control which is useful for testing or IRB
+      # sessions.
+
+      def startup options = {}
+        start_adapter
+
+        Timeout.timeout(3) do
+          sleep 0.01 until Global.server
+        end
+
+        Global.server.join unless Global.run_loose
+
+      rescue SystemExit
+        Ramaze.shutdown
+      rescue Object => ex
+        Log.error(ex)
+        Ramaze.shutdown
+      end
+
+      # Takes Global.adapter and starts if test_connections is positive that a
+      # connection can be made to the specified host and port.
+      # If you set Global.adapter to false it won't start any but deploy a
+      # dummy which is useful for testing purposes where you just send fake
+      # requests to Dispatcher.
+
+      def start_adapter
+        if adapter = Global.adapter
+          host, port = Global.host, Global.port
+
+          if Global.test_connections
+            test_connection(host, port)
+            Log.info("Ramaze is ready to run on: #{host}:#{port} using #{Global.adapter}")
+          end
+
+          adapter.start(host, port)
+        else
+          Fake.start
+          Log.warn("Seems like Global.adapter is turned off", "Continue without adapter.")
+        end
+      rescue LoadError => ex
+        Log.error(ex)
+        Log.warn("Continue without adapter.")
+      end
+
+      # Calls ::shutdown on all running adapters and waits up to 1 second for
+      # them to finish, then goes on to kill them and exit still.
+
+      def shutdown
+        Timeout.timeout(3) do
+          if Global.server.respond_to?(:shutdown)
+            Global.server.shutdown
+          end
+        end
+      rescue Timeout::Error
+        Global.server.kill!
+      end
+
+      # Opens a TCPServer temporarily and returns true if a connection is
+      # possible and false if none can be made
+
+      def test_connection(host, port)
+        Timeout.timeout(1) do
+          testsock = TCPServer.new(host, port)
+          testsock.close
+          true
+        end
+      rescue => ex
+        Log.error(ex)
+        Log.error("Cannot open connection on #{host}:#{port}")
+        Ramaze.shutdown
+      end
+    end
+  end
+end