ramaze 0.1.0 → 0.1.1

data/lib/ramaze/action.rb

@@ -0,0 +1,21 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  unless defined?(Action) # prevent problems for SourceReload
+
+    # The Action holds information that is essential to render the action for a
+    # request.
+
+    class Action < Struct.new('Action', :controller, :method, :params, :template, :binding)
+      def to_s
+        %{#<Action method=#{method.inspect}, params=#{params.inspect} template=#{template.inspect}>}
+      end
+
+      def params=(*par)
+        self[:params] = par.flatten.map{|pa| CGI.unescape(pa)}
+      end
+    end
+  end
+end

data/lib/ramaze/adapter.rb

@@ -1,54 +1,119 @@
 #          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'rack'
+require 'socket'
+require 'timeout'
 require 'benchmark'
 
+require 'rack'
+require 'rack/utils'
+
 require 'ramaze/trinity'
+require 'ramaze/tool/record'
+require 'ramaze/adapter/base'
 
 # for OSX compatibility
 Socket.do_not_reverse_lookup = true
 
-class Rack::Request
-  include Ramaze::Request
-end
+module Ramaze
 
-class Rack::Response
-  include Ramaze::Response
-end
+  # Shortcut to the HTTP_STATUS_CODES of Rack::Utils
+  # inverted for easier access
+
+  STATUS_CODE = Rack::Utils::HTTP_STATUS_CODES.invert
 
-module Ramaze::Adapter
-  class Base
+  # This module holds all classes and methods related to the adapters like
+  # webrick or mongrel.
+  # It's responsible to start and stop them.
+
+  module Adapter
     class << self
-      def stop
-        Inform.debug("Stopping #{self.class}")
+
+      # 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.adapters.list.any?
+        end
+
+        Global.adapters.list.each{|a| a.join} unless Global.run_loose
+
+      rescue SystemExit
+        Ramaze.shutdown
+      rescue Object => ex
+        Inform.error(ex)
+        Ramaze.shutdown
       end
 
-      def call(env)
-        new.call(env)
+      # Takes Global.adapter and starts if test_connections is positive that
+      # connections can be made to the specified host and ports.
+      # 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, ports = Global.host, Global.ports
+
+          Inform.info("Adapter: #{adapter}, testing connection to #{host}:#{ports}")
+          test_connections(host, ports)
+
+          Inform.info("and we're running: #{host}:#{ports}")
+          adapter.start(host, ports)
+        else # run dummy
+          Global.adapters.add Thread.new{ sleep }
+          Inform.warn("Seems like Global.adapter is turned off", "Continue without adapter.")
+        end
+      rescue LoadError => ex
+        Inform.warn(ex, "Continue without adapter.")
       end
-    end
 
-    def call(env)
-      if Ramaze::Global.benchmarking
-        time = Benchmark.measure{ respond env }
-        Inform.debug("request took #{time.real}s")
-      else
-        respond env
+      # 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(1) do
+          Global.adapters.list.each do |adapter|
+            a = adapter[:adapter]
+            a.shutdown if a.respond_to?(:shutdown)
+          end
+        end
+      rescue Timeout::Error
+        Global.adapters.list.each{|a| a.kill!}
+        exit!
       end
 
-      finish
-    end
+      # check the given host and ports via test_connection.
+      # Shuts down if no connection is possible.
 
-    def finish
-      response = Thread.current[:response]
+      def test_connections host, ports
+        return unless Global.test_connections
 
-      response.finish
-    end
+        ports.each do |port|
+          unless test_connection(host, port)
+            Inform.error("Cannot open connection on #{host}:#{port}")
+            Ramaze.shutdown
+          end
+        end
+      end
 
-    def respond env
-      request, response = Rack::Request.new(env), Rack::Response.new
-      Ramaze::Dispatcher.handle(request, response)
+      # 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
+          TCPServer.open(host, port){ true }
+        end
+      rescue => ex
+        Inform.error(ex)
+        false
+      end
     end
   end
 end

data/lib/ramaze/adapter/base.rb

@@ -0,0 +1,57 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Adapter
+
+    # This class is holding common behaviour for its subclasses.
+
+    class Base
+      class << self
+
+        # For the specified host and for all given ports call run_server and
+        # add the returned thread to the Global.adapters ThreadGroup.
+        # Afterwards adds a trap for the value of Global.shutdown_trap which
+        # calls Ramaze.shutdown when triggered (usually by SIGINT).
+
+        def start host, ports
+          ports.each do |port|
+            Global.adapters.add(run_server(host, port))
+            trap(Global.shutdown_trap){ Ramaze.shutdown }
+          end
+        end
+
+        # Does nothing
+
+        def stop
+          Inform.debug("Stopping #{self.class}")
+        end
+
+        def call(env)
+          if Ramaze::Global.benchmarking
+            time = Benchmark.measure{ respond env }
+            Inform.debug("request took #{time.real}s")
+          else
+            respond env
+          end
+
+          finish
+        end
+
+        def finish
+          response = Thread.current[:response]
+
+          response.finish
+        end
+
+        def respond env
+          request, response = Request.new(env), Response.new
+          if filter = Global.record
+            Record << request if filter[request]
+          end
+          Dispatcher.handle(request, response)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/mongrel.rb

@@ -2,27 +2,20 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'ramaze/adapter'
-
 require 'mongrel'
+require 'rack/handler/mongrel'
 
-module Ramaze::Adapter
-  class Mongrel < Base
-    class << self
-      def start host, ports
-        ports.map{|port| run_server(host, port) }.first
-      end
-
-      def run_server host, port
-        server = ::Mongrel::HttpServer.new(host, port)
-        server.register('/', ::Rack::Handler::Mongrel.new(self))
-        server.run
-      end
-
-      def stop
-      end
-
-      def call(env)
-        new.call(env)
+module Ramaze
+  module Adapter
+    class Mongrel < Base
+      class << self
+        def run_server host, port
+          server = ::Mongrel::HttpServer.new(host, port)
+          server.register('/', ::Rack::Handler::Mongrel.new(self))
+          thread = server.run
+          thread[:adapter] = server
+          thread
+        end
       end
     end
   end

data/lib/ramaze/adapter/webrick.rb

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'ramaze/adapter'
-
+require 'webrick'
 require 'rack/handler/webrick'
 
 module WEBrick
@@ -14,27 +14,28 @@ module WEBrick
   end
 end
 
-module Ramaze::Adapter
-  class Webrick < Base
-    class << self
-      def start host, ports
-        ports.map{|port| run_server(host, port) }.first
-      end
+module Ramaze
+  module Adapter
+    class WEBrick < Base
+      class << self
+        def run_server host, port, options = {}
+          options = {
+            :Port        => port,
+            :BindAddress => host,
+            :Logger      => Inform,
+            :AccessLog   => [
+              [Inform, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+              [Inform, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
+            ]
+          }.merge(options)
 
-      def run_server host, port, options = {}
-        options = {
-          :Port => port,
-          :BindAddress => host,
-          :Logger => Ramaze::Inform,
-          :AccessLog => [
-            [Ramaze::Inform, WEBrick::AccessLog::COMMON_LOG_FORMAT],
-            [Ramaze::Inform, WEBrick::AccessLog::REFERER_LOG_FORMAT]
-          ]
-        }.merge(options)
 
-        Thread.new do
-          Thread.current[:adapter] =
-            Rack::Handler::WEBrick.run(self, options)
+          server = ::WEBrick::HTTPServer.new(options)
+          server.mount("/", ::Rack::Handler::WEBrick, self)
+          thread = Thread.new(server) do |adapter|
+            Thread.current[:adapter] = adapter
+            adapter.start
+          end
         end
       end
     end

data/lib/ramaze/cache.rb

@@ -1,11 +1,55 @@
 #          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
+require 'ramaze/cache/memory'
+
 module Ramaze
-  autoload :MemoryCache, "ramaze/cache/memory.rb"
   autoload :YAMLStoreCache, "ramaze/cache/yaml_store.rb"
   autoload :MemcachedCache, "ramaze/cache/memcached.rb"
 
-  Cache = nil
-  SessionCache = nil
+  # This is the wrapper of all caches, providing mechanism
+  # for switching caching from one adapter to another.
+
+  class Cache
+    include Enumerable
+    CACHES = {}
+
+    # This will define a method to access a new cache directly over
+    # sinleton-methods on Cache
+
+    def self.add *keys
+      keys.each do |key|
+        CACHES[key] = new
+        self.class.class_eval do
+          define_method(key){ CACHES[key] }
+        end
+      end
+    end
+
+    def initialize(cache = Global.cache)
+      @cache = cache.new
+    end
+
+    def [](key)
+      @cache[key.to_s]
+    end
+
+    def []=(key, value)
+      @cache[key.to_s] = value
+    end
+
+    def delete(*args)
+      args.each do |arg|
+        @cache.delete(arg.to_s)
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      if @cache.respond_to?(meth)
+        @cache.send(meth, *args, &block)
+      else
+        super
+      end
+    end
+  end
 end

data/lib/ramaze/cache/memcached.rb

@@ -59,3 +59,25 @@ module Ramaze
     end
   end
 end
+
+# add the MemCache#clear method
+
+class MemCache
+  def clear
+    raise MemCacheError, "Update of readonly cache" if @readonly
+
+    @servers.each do |server|
+      server.flush_all
+    end
+  end
+
+  class Server
+    def flush_all
+      @mutex.lock if @multithread
+
+      socket.write "flush_all\r\n"
+    ensure
+      @mutex.unlock if @multithread
+    end
+  end
+end

data/lib/ramaze/cache/yaml_store.rb

@@ -5,10 +5,13 @@ require 'yaml/store'
 module Ramaze
   class YAMLStoreCache
 
+    attr_accessor :file
+
     # create a new YAML::Store with the given file (which will be created if it
     # is not already there).
 
     def initialize(file = 'cache.yaml')
+      @file = file
       @cache = YAML::Store.new(file)
     end
 
@@ -20,6 +23,22 @@ module Ramaze
       end
     end
 
+    def underlying_yaml
+      YAML.load_file(@file)
+    end
+
+    def clear
+      transaction do |y|
+        File.open(@file, 'w+'){|f| f.puts({}.to_yaml)}
+      end
+    end
+
+    def delete(key)
+      transaction do |y|
+        y.delete(key)
+      end
+    end
+
     # just a helper to use transactions.
 
     def transaction(&block)