ramaze 2011.01.30 → 2011.07.25

data/lib/ramaze/bin/start.rb

@@ -0,0 +1,206 @@
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # The start command is used to start a Ramaze application. The ramaze start
+    # command optionally takes a directory or path to a file. If it's a
+    # directory this command will look for a Rackup file in that directory,
+    # otherwise it assumes the specified file is a Rackup file.
+    #
+    # == Usage
+    #
+    #  ramaze start
+    #  ramaze start /home/foobar/projects/blog/config.ru
+    #  ramaze start /home/foobar/projects/blog
+    #
+    # @author Yorick Peterse
+    # @since  21-07-2011
+    #
+    class Start
+      include Ramaze::Bin::Helper
+
+      # The description of this command, displayed when the global help menu is
+      # invoked.
+      Description = 'Starts an instance of an application'
+
+      # The banner of this command, displayed when it's invoked with the -h or
+      # --help option.
+      Banner = <<-TXT.strip
+Starts an instance of an application using the settings
+specified in a Rackup file in the current directory.
+
+Usage:
+  ramaze start [RACKUP CONFIG] [OPTIONS]
+
+Example:
+  ramaze start --help
+      TXT
+
+      ##
+      # Creates a new instance of the command and prepares OptionParser.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      #
+      def initialize
+        @ruby_options = {}
+        @rack_options = {}
+        @options      = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          # Sets all Ruby options
+          opt.separator "\nRuby Options:\n"
+
+          opt.on('-e', '--eval LINE', 'Evaluates a line of code') do |code|
+            @ruby_options['-e'] = code
+          end
+
+          opt.on('-d', '--debug', 'Set debugging flags (set $DEBUG to true)') do
+            @ruby_options['-d'] = nil
+          end
+
+          opt.on('-w', '--warn', 'Turns warnings on for the script') do
+            @ruby_options['-w'] = nil
+          end
+
+          opt.on('-I', '--include PATH', 'specifies the $LOAD_PATH') do |path|
+            @ruby_options['-I'] = path
+          end
+
+          opt.on(
+            '-r',
+            '--require LIBRARY',
+            'requires the library before starting'
+          ) do |library|
+            @ruby_options['-r'] = library
+          end
+
+          # Set all Rack options
+          opt.separator "\nRack Options:\n"
+
+          opt.on(
+            '-s',
+            '--server SERVER',
+            'Serve the application using the given server'
+          ) do |server|
+            @rack_options['-s'] = server
+          end
+
+          opt.on(
+            '-o',
+            '--host HOST',
+            'Listens on the given host (0.0.0.0 by default)'
+          ) do |host|
+            @rack_options['-o'] = host
+          end
+
+          opt.on(
+            '-p',
+            '--port PORT',
+            'Uses the given port, set to 9292 by default'
+          ) do |port|
+            @rack_options['-p'] = port
+          end
+
+          opt.on(
+            '-O',
+            '--option NAME[=VALUE]',
+            'Passes the given option and it\'s value to the server'
+          ) do |name|
+            @rack_options['-O'] = name
+          end
+
+          opt.on(
+            '-E',
+            '--env ENVIRONMENT',
+            'Uses the specified environment, set to development by default'
+          ) do |env|
+            @rack_options['-E'] = env
+          end
+
+          opt.on('-D', '--daemonize', 'Runs as a daemon in the background') do
+            @rack_options['-D'] = nil
+          end
+
+          opt.on(
+            '-P',
+            '--pid FILE',
+            'File to store the PID in, defaults to rack.pid'
+          ) do |pid|
+            @rack_options['-P'] = pid
+          end
+
+          # Set all common options
+          opt.separator "\nOptions\n"
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts @options
+            exit
+          end
+        end
+      end
+
+      ##
+      # Runs the command based on the given command line arguments.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @param  [Array] argv An array of command line arguments.
+      #
+      def run(argv = [])
+        begin
+          @options.parse!(argv)
+        rescue => e
+          warn "Error: #{e.message}"
+          abort @options.to_s
+        end
+
+        # Remove all trailing/leading whitespace from the options
+        @rack_options.each do |k, v|
+          @rack_options[k] = v.strip if v.respond_to?(:strip)
+        end
+
+        @ruby_options.each do |k, v|
+          @ruby_options[k] = v.strip if v.respond_to?(:strip)
+        end
+
+        rackup_config = argv.delete_at(0)
+        rackup_config = File.join(Dir.pwd, 'config.ru') if rackup_config.nil?
+
+        # Check if the config is a directory or file
+        if File.directory?(rackup_config)
+          rackup_config = File.join(rackup_config, 'config.ru')
+        end
+
+        if !File.exist?(rackup_config)
+          abort "The Rackup config #{rackup_config} does not exist"
+        end
+
+        # Set the default port and server to use.
+        if !@rack_options['-p']
+          @rack_options['-p'] = 7000
+        end
+
+        # Set the default server to use
+        if !@rack_options['-s']
+          @rack_options['-s'] = Ramaze.options.adapter.handler.to_s
+        end
+
+        # If a PID is supplied we should first check to see if Ramaze isn't
+        # already running.
+        if @rack_options.key?('-P') and is_running?(@rack_options['-P'])
+          abort 'This application is already running'
+        end
+
+        params = []
+
+        @ruby_options.merge(@rack_options).each do |opt, value|
+          params.push("#{opt}#{value}")
+        end
+
+        exec('ruby', rackup_path, rackup_config, *params)
+      end
+    end # Start
+  end # Bin
+end # Ramaze

data/lib/ramaze/bin/status.rb

@@ -0,0 +1,152 @@
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # The status command can be used to show the details, such as the PID and
+    # the CPU usage, of a running Ramaze application.
+    #
+    # == Usage
+    #
+    #  ramaze status
+    #  ramaze status /home/projects/ramaze/ramaze.pid
+    #
+    # @author Yorick Peterse
+    # @author TJ Vanderpoel
+    # @since  21-07-2011
+    #
+    class Status
+      include Ramaze::Bin::Helper
+
+      # Description of this command, displayed in the glboal help message.
+      Description = 'Shows the status of a running Ramaze application'
+
+      # The banner of this command, displayed when the -h or --help option is
+      # specified.
+      Banner = <<-TXT.strip
+Shows the status of a running Ramaze application. If a PID is specified this
+command will use that PID, otherwise it will try to look for a PID in the
+current directory.
+
+Usage:
+  ramaze status [PID] [OPTIONS]
+
+Example:
+  ramaze status blog/blog.pid
+      TXT
+
+      # String containing the message that's used to display all statistics
+      Statistics = <<-TXT.strip
+Ramaze is running!
+Name: %s
+Command Line: %s
+Virtual Size: %s
+Started: %s
+Exec Path: %s
+Status: %s
+      TXT
+
+      ##
+      # Creates a new instance of the command and sets all the option parser
+      # options.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      #
+      def initialize
+        @options = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          opt.separator "\nOptions:\n"
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts @options
+            exit
+          end
+        end
+      end
+
+      ##
+      # Runs the command based on the given command line arguments.
+      #
+      # @author Yorick Peterse
+      # @author TJ Vanderpoel
+      # @since  21-07-2011
+      # @param  [Array] argv Array containing all teh command line arguments.
+      #
+      def run(argv = [])
+        @options.parse!(argv)
+
+        pid_path = argv.delete_at(0)
+        dirname  = Pathname.new('.').realpath.basename.to_s
+        pid_path = File.join(Dir.pwd, dirname + '.pid') if pid_path.nil?
+
+        # Is it a directory?
+        if File.directory?(pid_path)
+          pid_path = File.join(pid_path, File.basename(pid_path) + '.pid')
+        end
+
+        pid_path = Pathname.new(pid_path).expand_path.to_s
+
+        if !File.exist?(pid_path)
+          abort "The PID #{pid_path} does not exist"
+        end
+
+        # Is the app running?
+        unless is_running?(pid_path)
+          abort "The Ramaze application for #{pid_path} isn't running"
+        end
+
+        pid = File.read(pid_path).to_i
+
+        # Gather various statistics about the process
+        if is_windows?
+          wmi       = WIN32OLE.connect("winmgmts://")
+          ours      = []
+          processes = wmi.ExecQuery(
+            "select * from win32_process where ProcessId = #{pid}"
+          )
+
+          processes.each do |p|
+            ours << [
+              p.Name,
+              p.CommandLine,
+              p.VirtualSize,
+              p.CreationDate,
+              p.ExecutablePath,
+              p.Status
+            ]
+          end
+
+          puts Statistics % ours.first
+        # Unix like systems
+        else
+          if File.directory?(proc_dir = Pathname.new('/proc'))
+            proc_dir = proc_dir.join(pid.to_s)
+            # If we have a "stat" file, we'll assume linux and get as much info
+            # as we can
+            if File.file?(stat_file = proc_dir.join("stat"))
+              stats = File.read(stat_file).split
+
+              puts Statistics % [
+                nil,
+                File.read(proc_dir.join("cmdline")).split("\000").join(" "),
+                "%s k" % (stats[22].to_f / 1024),
+                File.mtime(proc_dir),
+                File.readlink(proc_dir.join("exe")),
+                stats[2]
+              ]
+            end
+          # /proc does not exist, use "ps"
+          else
+            begin
+              puts %x{ps l #{pid}}
+            rescue
+              puts "Sadly no more information is available"
+            end
+          end
+        end
+      end
+    end # Status
+  end # Bin
+end # Ramaze

data/lib/ramaze/bin/stop.rb

@@ -0,0 +1,112 @@
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # Stops a running instance of Ramaze by killing it's process. The PID of
+    # this process can be supplied via the command line. If no PID is given this
+    # command tries to find it in the current directory. If the latter is the
+    # case this command tries to find a file of which the name matches the name
+    # of the current directory.
+    #
+    # == Usage
+    #
+    #  ramaze stop
+    #  ramaze stop /home/foobar/projects/ramaze/ramaze.pid
+    #
+    # @author Yorick Peterse
+    # @author TJ Vanderpoel
+    # @since  21-07-2011
+    #
+    class Stop
+      include Ramaze::Bin::Helper
+
+      # The description of this command, shown when the global help menu is
+      # displayed.
+      Description = 'Stops a running instance of Ramaze'
+
+      # The banner of this command.
+      Banner = <<-TXT.strip
+Stops a running instance of Ramaze by killing it's process using a PID. If no
+PID is given this command tries to look for it in the current directory.
+
+Usage:
+  ramaze stop [PID] [OPTIONS]
+
+Example:
+  ramaze stop /home/foobar/projects/ramaze/ramaze.pid
+      TXT
+
+      ##
+      # Creates a new instance of the command and sets all the OptionParser
+      # options.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      #
+      def initialize
+        @options = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          opt.separator "\nOptions:\n"
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts @options
+            exit
+          end
+        end
+      end
+
+      ##
+      # Runs the command based on the specified command line arguments.
+      #
+      # @author Yorick Peterse
+      # @author TJ Vanderpoel
+      # @since  21-07-2011
+      # @param  [Array] argv Array containing all the command line arguments.
+      #
+      def run(argv = [])
+        @options.parse!(argv)
+
+        pid_path = argv.delete_at(0)
+        dirname  = Pathname.new('.').expand_path.basename.to_s
+        pid_path = File.join(Dir.pwd, dirname + '.pid') if pid_path.nil?
+
+        if File.directory?(pid_path)
+          pid_path = File.join(pid_path, File.basename(pid_path) + '.pid')
+        end
+
+        pid_path = Pathname.new(pid_path).expand_path.to_s
+
+        if !File.exist?(pid_path)
+          abort "The PID #{pid_path} does not exist"
+        end
+
+        pid = File.read(pid_path).to_i
+        puts 'Stopping the process using SIGINT'
+
+        begin
+          Process.kill('INT', pid)
+        rescue => e
+          abort "Failed to kill the process: #{e.message}"
+        end
+
+        sleep(2)
+
+        # Verify that the process has been killed
+        if is_running?(pid_path)
+          $stderr.puts "The process is still running, let's kill it with -9"
+
+          begin
+            Process.kill(9, pid)
+          rescue => e
+            abort "Failed to kill the process: #{e.message}"
+          end
+        end
+
+        File.unlink(pid_path) if File.exist?(pid_path)
+        puts 'Ramazement has ended, go in peace.'
+      end
+    end # Stop
+  end # Bin
+end # Ramaze