joe-merb-core 0.9.8

data/lib/merb-core/rack/middleware/tracer.rb

@@ -0,0 +1,20 @@
+module Merb
+  module Rack
+    class Tracer < Merb::Rack::Middleware
+
+      def call(env)
+
+        Merb.logger.debug!("Rack environment:\n" + env.inspect + "\n\n")
+
+        status, headers, body = @app.call(env)
+
+        Merb.logger.debug!("Status: #{status.inspect}")
+        Merb.logger.debug!("Headers: #{headers.inspect}")
+        Merb.logger.debug!("Body: #{body.inspect}")
+
+        [status, headers, body]
+      end
+      
+    end
+  end
+end

data/lib/merb-core/server.rb

@@ -0,0 +1,321 @@
+require 'etc'
+
+module Merb
+
+  # Server encapsulates the management of Merb daemons.
+  class Server
+    class << self
+
+      # Start a Merb server, in either foreground, daemonized or cluster mode.
+      #
+      # ==== Parameters
+      # port<~to_i>::
+      #   The port to which the first server instance should bind to.
+      #   Subsequent server instances bind to the immediately following ports.
+      # cluster<~to_i>::
+      #   Number of servers to run in a cluster.
+      #
+      # ==== Alternatives
+      # If cluster is left out, then one process will be started. This process
+      # will be daemonized if Merb::Config[:daemonize] is true.
+      def start(port, cluster=nil)
+        
+        @port = port
+        @cluster = cluster        
+
+        if Merb::Config[:daemonize]
+          pidfile = pid_file(port)
+          pid = File.read(pidfile).chomp.to_i if File.exist?(pidfile)
+
+          unless alive?(@port)
+            remove_pid_file(@port)
+            puts "Daemonizing..." if Merb::Config[:verbose]
+            daemonize(@port)
+          else
+            Merb.fatal! "Merb is already running on port #{port}.\n" \
+              "\e[0m   \e[1;31;47mpid file: \e[34;47m#{pidfile}" \
+              "\e[1;31;47m, process id is \e[34;47m#{pid}."
+          end
+        else
+          bootup
+        end
+      end
+
+      # ==== Parameters
+      # port<~to_s>:: The port to check for Merb instances on.
+      #
+      # ==== Returns
+      # Boolean::
+      #   True if Merb is running on the specified port.
+      def alive?(port)
+        puts "About to check if port #{port} is alive..." if Merb::Config[:verbose]
+        pidfile = pid_file(port)
+        puts "Pidfile is #{pidfile}..." if Merb::Config[:verbose]
+        pid = File.read(pidfile).chomp.to_i
+        puts "Process id is #{pid}" if Merb::Config[:verbose]
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::ENOENT
+        false
+      rescue Errno::EACCES => e
+        Merb.fatal!("You don't have access to the PID file at #{pidfile}.", e)
+      end
+
+      # ==== Parameters
+      # port<~to_s>:: The port of the Merb process to kill.
+      # sig<~to_s>:: The signal to send to the process. Defaults to 9.
+      #
+      # ==== Alternatives
+      # If you pass "all" as the port, the signal will be sent to all Merb
+      # processes.
+      def kill(port, sig="INT")
+        Merb::BootLoader::BuildFramework.run
+        if sig == 9 && port == "main"
+          kill_pid("INT", pid_file("main"))
+          Dir["#{Merb.log_path}" / "*.pid"].each do |file|
+            kill_pid(9, file)
+          end
+        else
+          kill_pid(sig, pid_file(port))
+        end
+
+        if sig.is_a?(Integer)
+          sig = Signal.list.invert[sig]
+        end
+
+        if sig == "KILL" && port == "main"
+          Merb.fatal! "Killed all PIDs with signal KILL"
+        else
+          Merb.fatal! "Killed #{port} with signal #{sig}"
+        end
+      end
+      
+      def kill_pid(sig, file)
+        begin
+          pid = File.read(file).chomp.to_i
+          Merb.logger.warn! "Killing pid #{pid}"
+          Process.kill(sig, pid)
+          FileUtils.rm(file) if File.exist?(file)
+        rescue Errno::EINVAL
+          Merb.fatal! "Failed to kill PID #{pid}: '#{sig}' is an invalid " \
+            "or unsupported signal number."
+        rescue Errno::EPERM
+          Merb.fatal! "Failed to kill PID #{pid}: Insufficient permissions."
+        rescue Errno::ESRCH
+          FileUtils.rm file
+          Merb.fatal! "Failed to kill PID #{pid}: Process is " \
+            "deceased or zombie."
+        rescue Errno::EACCES => e
+          Merb.fatal! e.message, e
+        rescue Errno::ENOENT => e
+          Merb.fatal! "Could not find a PID file at #{file}", e
+        rescue Exception => e
+          if !e.is_a?(SystemExit)
+            Merb.fatal! "Failed to kill PID #{pid}", e
+          end
+        end
+      end
+
+      # ==== Parameters
+      # port<~to_s>:: The port of the Merb process to daemonize.
+      def daemonize(port)
+        puts "About to fork..." if Merb::Config[:verbose]
+        fork do
+          Process.setsid
+          exit if fork
+          Merb.logger.warn! "In #{Process.pid}" if Merb.logger
+          File.umask 0000
+          STDIN.reopen "/dev/null"
+          STDOUT.reopen "/dev/null", "a"
+          STDERR.reopen STDOUT
+          begin
+            Dir.chdir Merb::Config[:merb_root]
+          rescue Errno::EACCES => e
+            Merb.fatal! "You specified #{Merb::Config[:merb_root]} " \
+              "as the Merb root, but you did not have access to it.", e
+          end
+          at_exit { remove_pid_file(port) }
+          Merb::Config[:port] = port
+          bootup
+        end
+      rescue NotImplementedError => e
+        Merb.fatal! "Daemonized mode is not supported on your platform", e
+      end
+      
+      def bootup
+        trap('TERM') { exit }
+
+        puts "Running bootloaders..." if Merb::Config[:verbose]
+        BootLoader.run
+        puts "Starting Rack adapter..." if Merb::Config[:verbose]
+        Merb.adapter.start(Merb::Config.to_hash)
+      end
+
+      def change_privilege
+        if Merb::Config[:user] && Merb::Config[:group]
+          Merb.logger.verbose! "About to change privilege to group " \
+            "#{Merb::Config[:group]} and user #{Merb::Config[:user]}"
+          _change_privilege(Merb::Config[:user], Merb::Config[:group])
+        elsif Merb::Config[:user]
+          Merb.logger.verbose! "About to change privilege to user " \
+            "#{Merb::Config[:user]}"
+          _change_privilege(Merb::Config[:user])
+        else
+          return true
+        end
+      end
+
+      # Removes a PID file used by the server from the filesystem.
+      # This uses :pid_file options from configuration when provided
+      # or merb.<port>.pid in log directory by default.
+      #
+      # ==== Parameters
+      # port<~to_s>::
+      #   The port of the Merb process to whom the the PID file belongs to.
+      #
+      # ==== Alternatives
+      # If Merb::Config[:pid_file] has been specified, that will be used
+      # instead of the port based PID file.
+      def remove_pid_file(port)
+        pidfile = pid_file(port)
+        if File.exist?(pidfile)
+          puts "Removing pid file #{pidfile} (port is #{port})..."
+          FileUtils.rm(pidfile)
+        end
+      end
+
+      # Stores a PID file on the filesystem.
+      # This uses :pid_file options from configuration when provided
+      # or merb.<port>.pid in log directory by default.
+      #
+      # ==== Parameters
+      # port<~to_s>::
+      #   The port of the Merb process to whom the the PID file belongs to.
+      #
+      # ==== Alternatives
+      # If Merb::Config[:pid_file] has been specified, that will be used
+      # instead of the port based PID file.
+      def store_pid(port)
+        store_details(port)
+      end
+
+      def remove_pid(port)
+        FileUtils.rm(pid_file(port)) if File.file?(pid_file(port))
+      end
+
+      def store_details(port = nil)
+        file = pid_file(port)
+        begin
+          FileUtils.mkdir_p(File.dirname(file))
+        rescue Errno::EACCES => e
+          Merb.fatal! "You tried to store Merb logs in #{File.dirname(file)}, " \
+            "but you did not have access.", e
+        end
+        Merb.logger.warn! "Storing #{type} file to #{file}..." if Merb::Config[:verbose]
+        File.open(file, 'w'){ |f| f.write(Process.pid.to_s) }
+      end
+
+      # Gets the pid file for the specified port.
+      #
+      # ==== Parameters
+      # port<~to_s>::
+      #   The port of the Merb process to whom the the PID file belongs to.
+      #
+      # ==== Returns
+      # String::
+      #   Location of pid file for specified port. If clustered and pid_file option
+      #   is specified, it adds the port value to the path.
+      def pid_file(port)
+        pidfile = Merb::Config[:pid_file] || (Merb.log_path / "merb.%s.pid")
+        pidfile % port
+      end
+
+      # Get a list of the pid files.
+      #
+      # ==== Returns
+      # Array::
+      #   List of pid file paths. If not clustered, array contains a single path.
+      def pid_files
+        if Merb::Config[:pid_file]
+          if Merb::Config[:cluster]
+            Dir[Merb::Config[:pid_file] % "*"]
+          else
+            [ Merb::Config[:pid_file] ]
+          end
+        else
+          Dir[Merb.log_path / "merb.*.pid"]
+        end
+       end
+
+      # Change privileges of the process to the specified user and group.
+      #
+      # ==== Parameters
+      # user<String>:: The user who should own the server process.
+      # group<String>:: The group who should own the server process.
+      #
+      # ==== Alternatives
+      # If group is left out, the user will be used as the group.
+      def _change_privilege(user, group=user)
+
+        Merb.logger.warn! "Changing privileges to #{user}:#{group}"
+
+        uid, gid = Process.euid, Process.egid
+        
+        begin
+          target_uid = Etc.getpwnam(user).uid
+        rescue ArgumentError => e
+          Merb.fatal!(
+            "You tried to use user #{user}, but no such user was found", e)
+          return false
+        end
+        
+        begin
+          target_gid = Etc.getgrnam(group).gid
+        rescue ArgumentError => e
+          Merb.fatal!(
+            "You tried to use group #{group}, but no such group was found", e)
+          return false
+        end
+
+        if uid != target_uid || gid != target_gid
+          # Change process ownership
+          Process.initgroups(user, target_gid)
+          Process::GID.change_privilege(target_gid)
+          Process::UID.change_privilege(target_uid)
+        end
+        true
+      rescue Errno::EPERM => e
+        Merb.fatal! "Couldn't change user and group to #{user}:#{group}", e
+        false
+      end
+
+      def add_irb_trap
+        trap('INT') do
+          if @interrupted
+            puts "Exiting\n"
+            exit
+          end
+          
+          @interrupted = true
+          puts "Interrupt a second time to quit"
+          Kernel.sleep 1.5
+          ARGV.clear # Avoid passing args to IRB
+
+          if @irb.nil?
+            require 'irb'
+            IRB.setup(nil)
+            @irb = IRB::Irb.new(nil)
+            IRB.conf[:MAIN_CONTEXT] = @irb.context
+          end
+
+          trap(:INT) { @irb.signal_handle }
+          catch(:IRB_EXIT) { @irb.eval_input }
+
+          puts "Exiting IRB mode, back in server mode"
+          @interrupted = false
+          add_irb_trap
+        end
+      end
+    end
+  end
+end

data/lib/merb-core/tasks/audit.rake

@@ -0,0 +1,68 @@
+namespace :audit do
+
+  desc "Print out the named and anonymous routes"
+  task :routes => :merb_env do
+    seen = []
+    unless Merb::Router.named_routes.empty?
+      puts "Named Routes"
+      Merb::Router.named_routes.each do |name,route|
+        puts "  #{name}: #{route}"
+        seen << route
+      end
+    end
+    puts "Anonymous Routes"
+    (Merb::Router.routes - seen).each do |route|
+      puts "  #{route}"
+    end
+    nil
+  end
+
+  desc "Print out all controllers"
+  task :controllers => :merb_env do
+    puts "\nControllers:\n\n"
+    abstract_controller_classes.each do |klass|
+      if klass.respond_to?(:subclasses_list)
+        puts "#{klass} < #{klass.superclass}"
+        subklasses = klass.subclasses_list.sort.map { |x| Object.full_const_get(x) }
+        unless subklasses.empty?
+          subklasses.each { |subklass| puts "- #{subklass}" }
+        else
+          puts "~ no subclasses"
+        end
+        puts
+      end
+    end
+  end
+  
+  desc "Print out controllers and their actions (use CONTROLLER=Foo,Bar to be selective)"
+  task :actions => :merb_env do
+    puts "\nControllers and their actions:\n\n"
+    filter_controllers = ENV['CONTROLLER'] ? ENV['CONTROLLER'].split(',') : nil
+    abstract_controllers = abstract_controller_classes
+    classes = Merb::AbstractController.subclasses_list.sort.map { |x| Object.full_const_get(x) }
+    classes = classes.select { |k| k.name.in?(filter_controllers) } if filter_controllers
+    classes.each do |subklass|
+      next if subklass.in?(abstract_controllers) || !subklass.respond_to?(:callable_actions)
+      puts "#{subklass} < #{subklass.superclass}"
+      unless subklass.callable_actions.empty?
+        subklass.callable_actions.sort.each do |action, null|
+          if subklass.respond_to?(:action_argument_list)
+            arguments, defaults = subklass.action_argument_list[action]
+            args = arguments.map { |name, value| value ? "#{name} = #{value.inspect}" : name.to_s }.join(', ')
+            puts args.empty? ? "- #{action}" : "- #{action}(#{args})"
+          else
+            puts "- #{action}"
+          end
+        end
+      else
+        puts "~ no callable actions"
+      end
+      puts
+    end    
+  end
+  
+  def abstract_controller_classes
+    ObjectSpace.classes.select { |x| x.superclass == Merb::AbstractController }.sort_by { |x| x.name }
+  end
+  
+end

data/lib/merb-core/tasks/gem_management.rb

@@ -0,0 +1,252 @@
+require 'rubygems'
+require 'rubygems/dependency_installer'
+require 'rubygems/uninstaller'
+require 'rubygems/dependency'
+
+module ColorfulMessages
+  
+  # red
+  def error(*messages)
+    puts messages.map { |msg| "\033[1;31m#{msg}\033[0m" }
+  end
+  
+  # yellow
+  def warning(*messages)
+    puts messages.map { |msg| "\033[1;33m#{msg}\033[0m" }
+  end
+  
+  # green
+  def success(*messages)
+    puts messages.map { |msg| "\033[1;32m#{msg}\033[0m" }
+  end
+  
+  alias_method :message, :success
+  
+end
+
+module GemManagement
+  
+  include ColorfulMessages
+  
+  # Install a gem - looks remotely and local gem cache;
+  # won't process rdoc or ri options.
+  def install_gem(gem, options = {})
+    from_cache = (options.key?(:cache) && options.delete(:cache))
+    if from_cache
+      install_gem_from_cache(gem, options)
+    else
+      version = options.delete(:version)
+      Gem.configuration.update_sources = false
+
+      update_source_index(options[:install_dir]) if options[:install_dir]
+
+      installer = Gem::DependencyInstaller.new(options.merge(:user_install => false))
+      exception = nil
+      begin
+        installer.install gem, version
+      rescue Gem::InstallError => e
+        exception = e
+      rescue Gem::GemNotFoundException => e
+        if from_cache && gem_file = find_gem_in_cache(gem, version)
+          puts "Located #{gem} in gem cache..."
+          installer.install gem_file
+        else
+          exception = e
+        end
+      rescue => e
+        exception = e
+      end
+      if installer.installed_gems.empty? && exception
+        error "Failed to install gem '#{gem} (#{version})' (#{exception.message})"
+      end
+      installer.installed_gems.each do |spec|
+        success "Successfully installed #{spec.full_name}"
+      end
+      return !installer.installed_gems.empty?
+    end
+  end
+
+  # Install a gem - looks in the system's gem cache instead of remotely;
+  # won't process rdoc or ri options.
+  def install_gem_from_cache(gem, options = {})
+    version = options.delete(:version)
+    Gem.configuration.update_sources = false
+    installer = Gem::DependencyInstaller.new(options.merge(:user_install => false))
+    exception = nil
+    begin
+      if gem_file = find_gem_in_cache(gem, version)
+        puts "Located #{gem} in gem cache..."
+        installer.install gem_file
+      else
+        raise Gem::InstallError, "Unknown gem #{gem}"
+      end
+    rescue Gem::InstallError => e
+      exception = e
+    end
+    if installer.installed_gems.empty? && exception
+      error "Failed to install gem '#{gem}' (#{e.message})"
+    end
+    installer.installed_gems.each do |spec|
+      success "Successfully installed #{spec.full_name}"
+    end
+  end
+
+  # Install a gem from source - builds and packages it first then installs.
+  def install_gem_from_src(gem_src_dir, options = {})
+    if !File.directory?(gem_src_dir)
+      raise "Missing rubygem source path: #{gem_src_dir}"
+    end
+    if options[:install_dir] && !File.directory?(options[:install_dir])
+      raise "Missing rubygems path: #{options[:install_dir]}"
+    end
+
+    gem_name = File.basename(gem_src_dir)
+    gem_pkg_dir = File.expand_path(File.join(gem_src_dir, 'pkg'))
+
+    # We need to use local bin executables if available.
+    thor = "#{Gem.ruby} -S #{which('thor')}"
+    rake = "#{Gem.ruby} -S #{which('rake')}"
+
+    # Handle pure Thor installation instead of Rake
+    if File.exists?(File.join(gem_src_dir, 'Thorfile'))
+      # Remove any existing packages.
+      FileUtils.rm_rf(gem_pkg_dir) if File.directory?(gem_pkg_dir)
+      # Create the package.
+      FileUtils.cd(gem_src_dir) { system("#{thor} :package") }
+      # Install the package using rubygems.
+      if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
+        FileUtils.cd(File.dirname(package)) do
+          install_gem(File.basename(package), options.dup)
+          return true
+        end
+      else
+        raise Gem::InstallError, "No package found for #{gem_name}"
+      end
+    # Handle elaborate installation through Rake
+    else
+      # Clean and regenerate any subgems for meta gems.
+      Dir[File.join(gem_src_dir, '*', 'Rakefile')].each do |rakefile|
+        FileUtils.cd(File.dirname(rakefile)) do 
+          system("#{rake} clobber_package; #{rake} package")
+        end
+      end
+
+      # Handle the main gem install.
+      if File.exists?(File.join(gem_src_dir, 'Rakefile'))
+        # Remove any existing packages.
+        FileUtils.cd(gem_src_dir) { system("#{rake} clobber_package") }
+        # Create the main gem pkg dir if it doesn't exist.
+        FileUtils.mkdir_p(gem_pkg_dir) unless File.directory?(gem_pkg_dir)
+        # Copy any subgems to the main gem pkg dir.
+        Dir[File.join(gem_src_dir, '*', 'pkg', '*.gem')].each do |subgem_pkg|
+          dest = File.join(gem_pkg_dir, File.basename(subgem_pkg))
+          FileUtils.copy_entry(subgem_pkg, dest, true, false, true)          
+        end
+
+        # Finally generate the main package and install it; subgems
+        # (dependencies) are local to the main package.
+        FileUtils.cd(gem_src_dir) do         
+          system("#{rake} package")
+          FileUtils.cd(gem_pkg_dir) do
+            if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
+              # If the (meta) gem has it's own package, install it.
+              install_gem(File.basename(package), options.dup)
+            else
+              # Otherwise install each package seperately.
+              Dir["*.gem"].each { |gem| install_gem(gem, options.dup) }
+            end
+          end
+          return true
+        end
+      end
+    end
+    raise Gem::InstallError, "No Rakefile found for #{gem_name}"
+  end
+
+  # Uninstall a gem.
+  def uninstall_gem(gem, options = {})
+    if options[:version] && !options[:version].is_a?(Gem::Requirement)
+      options[:version] = Gem::Requirement.new ["= #{options[:version]}"]
+    end
+    update_source_index(options[:install_dir]) if options[:install_dir]
+    Gem::Uninstaller.new(gem, options).uninstall
+  end
+
+  # Use the local bin/* executables if available.
+  def which(executable)
+    if File.executable?(exec = File.join(Dir.pwd, 'bin', executable))
+      exec
+    else
+      executable
+    end
+  end
+  
+  # Create a modified executable wrapper in the specified bin directory.
+  def ensure_bin_wrapper_for(gem_dir, bin_dir, *gems)
+    if bin_dir && File.directory?(bin_dir)
+      gems.each do |gem|
+        if gemspec_path = Dir[File.join(gem_dir, 'specifications', "#{gem}-*.gemspec")].last
+          spec = Gem::Specification.load(gemspec_path)
+          spec.executables.each do |exec|
+            executable = File.join(bin_dir, exec)
+            message "Writing executable wrapper #{executable}"
+            File.open(executable, 'w', 0755) do |f|
+              f.write(executable_wrapper(spec, exec))
+            end
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def executable_wrapper(spec, bin_file_name)
+    <<-TEXT
+#!/usr/bin/env ruby
+#
+# This file was generated by Merb's GemManagement
+#
+# The application '#{spec.name}' is installed as part of a gem, and
+# this file is here to facilitate running it.
+
+begin 
+  require 'minigems'
+rescue LoadError 
+  require 'rubygems'
+end
+
+if File.directory?(gems_dir = File.join(Dir.pwd, 'gems')) ||
+   File.directory?(gems_dir = File.join(File.dirname(__FILE__), '..', 'gems'))
+  $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(gems_dir)
+end
+
+version = "#{Gem::Requirement.default}"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem '#{spec.name}', version
+load '#{bin_file_name}'
+TEXT
+  end
+
+  def find_gem_in_cache(gem, version)
+    spec = if version
+      version = Gem::Requirement.new ["= #{version}"] unless version.is_a?(Gem::Requirement)
+      Gem.source_index.find_name(gem, version).first
+    else
+      Gem.source_index.find_name(gem).sort_by { |g| g.version }.last
+    end
+    if spec && File.exists?(gem_file = "#{spec.installation_path}/cache/#{spec.full_name}.gem")
+      gem_file
+    end
+  end
+
+  def update_source_index(dir)
+    Gem.source_index.load_gems_in(File.join(dir, 'specifications'))
+  end
+  
+end