homeq 1.1.4

data/lib/homeq/base/options.rb

@@ -0,0 +1,171 @@
+#############################################################################
+#
+# $Id: options.rb 42 2008-10-24 05:53:35Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+require 'optparse'
+require 'optparse/time'
+require 'ostruct'
+require 'singleton'
+require 'pp'
+
+module HomeQ
+
+  module Base
+
+    module Options
+
+      def options
+        @options ||= Options.instance.parse
+      end
+
+      class Options
+        include Singleton
+
+        attr :options, true
+        attr :parser, true
+
+        def initialize
+          @options               = OpenStruct.new
+          @options.log_level     = false
+          @options.config_file   = File.join(HOMEQ_APP_ROOT,
+                                             '/config/homeq.cfg')
+          @options.queue_name    = nil
+          @options.cp_port       = nil
+          @options.foreground    = false
+          @options.pid_file      = false
+          @options.log_file      = false
+          @options.dump_topology = false
+          @options.enable_debugging = false
+          
+          @parser = OptionParser.new do |opts|
+            opts.banner = "Usage: #{File.basename($0)} [options]"
+            
+            opts.separator ""
+            opts.separator "HOMEQ options:"
+
+            # Mandatory argument.
+            opts.on("-c", "--config-file FILE",
+                    "Configuration file; defaults to \n\
+                                     #{@options.config_file}") { |c|
+              @options.config_file = c
+            }
+            opts.on("-q", "--queuename NAME",
+                    "This process's queue name") { |q|
+              @options.queue_name = q
+            }
+            opts.on("-p", "--port PORT",
+                    Integer,
+                    "Control port to listen on.") { |p|
+              @options.cp_port = p
+            }
+            opts.on("-l", "--[no-]log-file LOGFILE",
+                    "Log to this file; defaults to \n\
+                                     #{@options.log_file}") { |o|
+              @options.log_file = o
+            }
+            opts.on("-P", "--pid-file FILE",
+                    "Write pid to this file;\n \
+                                    defaults to " +
+                    "/var/run/hq_<queuename>.pid") { |p|
+              @options.pid_file = p
+            }
+
+            # Boolean switches
+            
+            opts.on("-v",
+                    "--[no-]verbose",
+                    "Run verbosely. Additively -vvv") do |v|
+              @options.log_level = 0 unless @options.log_level
+              @options.log_level += 1
+            end
+            opts.on("-f", "--[no-]foreground", "Run in the foreground") do |o|
+              @options.foreground = o
+            end
+            opts.on("-T", "--print-topology",
+                    "Using command line options and config file,\n \
+                                    dump a topology in YAML format.") do |o|
+              @options.dump_topology = o
+            end
+            opts.on("-E", "--print-homeq-env",
+                    "Using command line options and config file,\n \
+                                    display currently set HOMEQ_ENV.") do |o|
+              @options.dump_env = o
+            end
+            opts.on("-D", "--enable-debugging",
+                    "Enable rdebug debugging") do |o|
+              @options.enable_debugging = o
+            end
+
+            opts.separator ""
+            opts.separator "Common options:"
+
+            opts.on("-h", "--help", "Show this message") do
+              puts opts
+              exit
+            end
+
+            # Another typical switch to print the version.
+            opts.on("--version", "Show version") do
+              puts OptionParser::Version.join('.')
+              Kernel::exit
+            end
+          end
+        end
+
+        #
+        # Return a structure describing the options.
+        #
+        def parse
+          # The options specified on the command line will be
+          # collected in *options*.  We set default values here.
+
+          begin
+            @parser.parse!(ARGV)
+          rescue OptionParser::ParseError => pe
+            puts @parser
+            raise
+          end
+
+          # Add our cute little override method
+          class << @options
+            def set_configuration(config)
+              @table.each { |k,v|
+                if config.respond_to?(k) && v
+                  config.send(k, v)
+                end
+              }
+            end
+          end
+          
+          @options
+        end  # parse()
+
+      end # class Options
+
+    end # module Options
+
+  end # module Base
+
+end # module HomeQ

data/lib/homeq/base/poolable.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/ruby
+
+#############################################################################
+#
+# $Id: homeq.rb 8 2008-08-27 20:15:22Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+module HomeQ
+  
+  module Poolable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    def recycle
+      deinitialize
+      if self.class.pool.size < self.class.pool_size
+        self.class.pool.push(self)
+      end
+    end
+    def deinitialize
+      raise "Must be overridden"
+    end
+    module ClassMethods
+      attr :pool, false
+      attr :pool_size, false
+      def pool_init(size)
+        @pool_size = size
+        @pool = []
+      end
+      def new(*args)
+        if @pool.any?
+          o = @pool.shift
+          o.send(:reinitialize, *args)
+          return o
+        end
+        super(*args)
+      end
+    end
+    
+  end # module Poolable
+
+end # module HomeQ
+
+if $0 == __FILE__
+
+  require 'test/unit/testsuite'
+  require 'test/unit'
+
+  class Foo
+    include HomeQ::Poolable
+    pool_init(1)
+    attr :x, true
+    def initialize(x)
+      @x = x
+    end
+    alias_method :reinitialize, :initialize
+    def deinitialize
+      instance_variables.each {|v|
+        eval "#{v} = nil"
+      }
+    end
+  end
+  
+  class TC_MyTest < Test::Unit::TestCase
+    def test_simple
+      f1 = Foo.new(23)
+      assert_equal(23, f1.x)
+      assert_equal(0, Foo.pool.size)
+      f1.recycle
+      assert_equal(1, Foo.pool.size)
+      assert_equal(nil, f1.x)
+      f2 = Foo.new(19)
+      assert_equal(19, f2.x)
+      assert_equal(f1.object_id, f2.object_id)
+      assert_equal(0, Foo.pool.size)
+    end
+  end
+  
+end

data/lib/homeq/base/system.rb

@@ -0,0 +1,446 @@
+#############################################################################
+#
+# $Id: system.rb 48 2008-11-19 05:11:59Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+require 'singleton'
+require 'observer'
+require 'ruby-prof'
+
+module HomeQ
+
+  module Base
+
+    class System
+
+      # Run periodic tasks every so many seconds
+      PERIOD_TASK_INTERVAL = 60
+
+      module HomeQ::Base::Commando::InstanceMethods
+        def start_profiling
+          sys.start_profiling
+        end
+        def stop_profiling
+          sys.stop_profiling
+        end
+        document_command "start_profiling", "Begin profiling"
+        document_command "stop_profiling", "End profiling.  Results to STDOUT."
+        def enable_debugging(*args)
+          sys.enable_debugging
+        end
+        def disable_debugging
+          sys.disable_debugging
+        end
+        def debug_now
+          sys.debug_now
+        end
+        def add_breakpoint(file, line, expr)
+          sys.add_breakpoint(file, line, expr)
+        end
+        def pid_file(filename=nil)
+          return sys.pid_file unless filename
+          sys.pid_file = filename
+        end
+        def config_file(filename=nil)
+          return sys.config_file unless filename
+          sys.config_file = filename
+        end
+        document_command "enable_debugging", "Begin debugging"
+        document_command("disable_debugging",
+                         "End debugging.  Results to STDOUT.")
+        document_command "debug_now", "Drop into debugger."
+        document_command "add_breakpoint(file,line,expr)", "Set a breakpoint."
+        config_accessor :foreground
+        config_accessor :dump_topology, 'Cough up topology in YAML format.'
+        config_accessor :dump_env, 'Cough up HOMEQ_ENV.'
+        config_accessor(:period_task_interval,
+                        "Run periodic tasks every so many seconds")
+
+        def show_queue(queuename)
+          unless queuename.is_a?(String)
+            return "Supply a queue name in string format, plz."
+          end
+          found = sys.servers.find { |s|
+            s.queue_name == queuename
+          }
+          found ||= sys.queues.find { |s|
+            s.queue_name == queuename
+          }
+          found || "Can't find that queue"
+        end
+        def show_queue_list
+          sys.servers.to_s + "\n" + sys.queues.to_s
+        end
+        document_command "show_queue(qname)", "Display info about a queue"
+        document_command :show_queue_list, "List queues"
+      end
+      
+      include Singleton
+      include Observable
+      include Base::Configuration
+      include Base::Logging
+      include Base::Options
+
+      attr :servers, true
+      attr :queues, true
+      attr :config_file, true
+      attr :cp_server, true
+      attr :handlers, true
+      attr :topology, true
+      attr :pid_file, true
+      
+      def initialize
+        @handlers 	= {}
+        @servers 	= []
+        @queues 	= []
+        @topology 	= HomeQ::SOBS::Topology::Topology.new
+        @state = Statemachine.build do
+          state :start do
+            event :init, :waiting_to_run, :delayed_init
+            event :error, :stopped
+          end
+          state :waiting_to_run do
+            on_entry :broadcast_change
+            event :init, :waiting_to_run
+            event :started, :running
+            event :stop, :stopped
+          end
+          state :running do
+            on_entry :broadcast_change
+            event :error, :stopped
+            event :stop, :stopped
+          end
+          state :stopped do
+            on_entry :shutdown
+            event :start, :running
+            event :stop, :stopped
+            event :started, :stopped
+            event :init, :running
+          end
+          state :exit do
+          end
+        end
+        @state.context = self
+        
+        catch_signals
+
+        setup_em
+      end
+
+      # Set the system in motion.  Initializes, reading command line
+      # args and config file, calls EventMachine::run.  If called with
+      # a block, it will yield to the block inside the block passed to
+      # EventMachine::run, so application code will have a chance to
+      # do any startup tasks inside the EventMachine::run block.
+      #
+      # After yielding to your application code (while still in the
+      # EventMachine::run block), it starts the server, queues, and
+      # the control port, and then away we go.
+      def start
+        @state.init
+        if @state.state == :waiting_to_run
+          EventMachine::set_descriptor_table_size(10000)
+          # TODO Hmm.  Use this?
+          # EventMachine::set_effective_user("nobody")
+          logger.info {
+            "Starting Eventmachine.  Pid: #{Process.pid} " +
+            "HOMEQ_ENV: #{HOMEQ_ENV} HOMEQ_APP_ROOT: #{HOMEQ_APP_ROOT}"
+          }
+          EventMachine::run {
+            yield if block_given?
+            HomeQ::SOBS::Server.create_home_queue(config.queue_name,
+                                                  @handlers[config.queue_name])
+            HomeQ::SOBS::Queue.create_queues_from_topology(config.queue_name)
+            @cp_server = CP::Server.new(config.cp_host, config.cp_port)
+            
+            @cp_server.start
+            start_servers
+            start_queues
+            start_periodic_tasks
+
+            @state.started
+          }
+        end
+      end
+
+      # Start a graceful shutdown.
+      def stop
+        @state.stop
+      end
+
+      # We don't do any nice cleanup, just go down fast.
+      def die(msg=nil, exit_status=-1)
+        logger.fatal(msg) if msg
+        exit!(exit_status)
+      end
+
+      # If debugging is already enabled (via enable_debugging), then
+      # call 'debugger'.
+      def debug_now
+        if @debugging
+          debugger
+        else
+          logger.info {
+            "Debugging not started."
+          }
+        end
+      end
+
+      # If not already enabled, setup for debugging by doing a
+      # require 'ruby-debug', and then a Debugger.start_remote()
+      def enable_debugging
+        if !@debugging
+          logger.info {
+            "Enabled debugging."
+          }
+          @debugging = true
+          require 'ruby-debug'
+          Debugger.start_remote
+        end
+      end
+
+      # If already debugging, disable it and call Debugger.stop().
+      def disable_debugging
+        if @debugging
+          logger.info {
+            "Disabled debugging"
+          }
+          @debugging = false
+          Debugger.stop
+        end
+      end
+
+      # Tell the debugger to break at the supplied file and line.
+      def add_breakpoint(file, line, expr)
+        Debugger.add_breakpoint(file, line, expr)
+      end
+
+      # Begin profiling
+      def start_profiling
+        if !@profiling
+          logger.info {
+            'Beginning profiling'
+          }
+          @profiling = true
+          RubyProf.start
+        end
+      end
+
+      # End profiling.  Results are printed to STDOUT.
+      def stop_profiling
+        if @profiling
+          logger.info {
+            'Ending profiling'
+          }
+          @profiling = false
+          result = RubyProf.stop
+          printer = RubyProf::GraphPrinter.new(result)
+          printer.print(STDOUT, 0)
+        end
+      end
+      
+      protected
+
+      # Make sure EventMachine is configured to our liking.
+      def setup_em
+        EventMachine::set_max_timers(1000000) 
+      end
+
+      # Tell folks something.
+      def broadcast_change
+        changed
+        notify_observers(self, @state.state)
+      end
+      
+      # Lazy initialization; called from start()
+      def delayed_init
+        begin
+          # The queue name and config file name are settings we need
+          # "early", during initialization.  If they're set on the
+          # command line, grab them now.
+          options.config_file && (@config_file = options.config_file)
+          options.queue_name && (config.queue_name = options.queue_name)
+
+          raise "No config file set?!" unless config_file
+          config.read_config_file(config_file)
+          options.set_configuration(config)
+          
+          if options.dump_topology
+            puts topology.to_yaml
+            exit
+          elsif options.dump_env
+            puts HOMEQ_ENV
+            exit
+          end
+
+          if config.foreground
+            HomeQ::Base::Logging::Logger.instance.stdout
+          else
+            demonize
+          end
+          
+        rescue OptionParser::ParseError => e
+          STDERR.puts e.message
+          exit(-1)
+        rescue SystemExit
+            exit
+        rescue Exception => e
+          raise
+        end
+      end
+
+      # Stop servers, queues and the control port.  Wait for everthing
+      # to wind down, then exit.
+      def shutdown
+        stop_servers
+        stop_queues
+        @cp_server.stop if @cp_server
+        bye_if_done
+      end
+
+      # Wait for everything to wind down.
+      def bye_if_done
+        EventMachine::next_tick {
+          if (!@queues.find { |q| q.connected? } &&
+              !@servers.find { |s| s.connections.any? })
+            EventMachine::stop_event_loop
+          else
+            @queues.find { |q| q.connected? }.class
+            @servers.find { |s| s.connections.any? }.class
+            bye_if_done
+          end
+        }
+      end
+
+      # Start period tasks timer
+      def start_periodic_tasks
+        interval = config.period_task_interval || PERIOD_TASK_INTERVAL
+        EventMachine::add_periodic_timer(interval) {
+          sys.run_periodic_tasks
+        }
+      end
+
+      # Do any period tasks
+      def run_periodic_tasks
+        logger.debug4 {
+          "Running periodic tasks."
+        }
+      end
+
+      # Call each server in turn, telling it to start.
+      def start_servers
+        @servers.each { |s|
+          s.start
+        }
+      end
+      
+      # Call each queue in turn, telling it to start.
+      def start_queues
+        @queues.each { |q|
+          q.start
+          if @handlers[q.queue_name]
+            q.handler = @handlers[q.queue_name]
+          end
+        }
+      end
+
+      def stop_servers
+        logger.debug {
+          "Stopping servers"
+        }
+        @servers.each { |s|
+          s.stop
+        }
+      end
+
+      def stop_queues
+        logger.debug {
+          "Stopping queues"
+        }
+        @queues.each { |q|
+          q.stop
+        }
+      end
+
+      def demonize
+        # Detach from controlling tty
+        parent = fork
+        exit! if parent
+        Process.setsid
+
+        # We want to be the grandchild.  This is probably redundant in
+        # everything but some old weird SysV systems.  But it seems to
+        # be the UNIX WAY(tm).
+        parent = fork
+        exit! if parent
+        
+        store_pid
+        File.umask 0000
+        STDIN.reopen "/dev/null"
+        if options.log_file
+          STDOUT.reopen options.log_file, "a"
+        else
+          STDOUT.reopen "/dev/null", "a"
+        end
+        STDERR.reopen STDOUT
+      end
+
+      def store_pid
+        begin
+          filename = config.pid_file || "/var/log/hq_#{config.queue_name}.pid"
+          if File.exists?(filename)
+            die "Already running?! Pid file #{filename}."
+          end
+          File.open(filename, 'w') { |f|
+            f.puts Process.pid.to_s
+          }
+        rescue Errno::EACCES
+          die "Insufficient permissions to write pid file '#{filename}'"
+        end
+      end
+
+      def catch_signals
+        Signal.trap("INT")  {
+          logger.info {
+            "Caught SIGINT; shutting down soon."
+          }
+          @state.stop
+        }
+        Signal.trap("USR1") {
+          @profiling ? stop_profiling : start_profiling
+        }
+        Signal.trap("USR2") {
+          logger.info {
+            "Caught SIGUSR2."
+          }
+          enable_debugging if !@debugging
+          debug_now
+        }
+      end
+
+    end # class System
+    
+  end # module Base
+
+end # HomeQ