pazuzu 0.1.2

data/lib/pazuzu/supervisor_runner.rb

@@ -0,0 +1,95 @@
+module Pazuzu
+
+  # Runs the supervisor daemon from the command line.
+  class SupervisorRunner
+
+    def initialize
+      @run_as_daemon = false
+    end
+
+    def run!(arguments = [])
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{prog_name} [OPTIONS]"
+        opts.separator ""
+        opts.on("-d", "--daemon", 'Run as daemon') do
+          @run_as_daemon = true
+        end
+        opts.on("-p PATH", "--pid", "Store pid in PATH (defaults to #{DEFAULT_PID_PATH})") do |value|
+          @pid_path = File.expand_path(value)
+        end
+        opts.on("-c FILE", "--config FILE", "Read configuration from FILE (defaults to #{DEFAULT_CONFIG_PATH})") do |value|
+          @config_path = File.expand_path(value)
+        end
+        opts.on("-h", "--help", "Show this help.") do
+          puts opts
+          exit
+        end
+        opts.parse!(arguments)
+      end
+
+      if @run_as_daemon
+        daemonize!
+      else
+        execute!
+      end
+    rescue => e
+      abort "#{prog_name}: #{e.message}"
+    end
+
+    private
+
+      DEFAULT_PID_PATH = '/var/run/pazuzud.pid'.freeze
+      DEFAULT_CONFIG_PATH = '/etc/pazuzu/pazuzu.conf'.freeze
+
+      def execute!
+        @config_path ||= DEFAULT_CONFIG_PATH
+        with_pid do
+          @supervisor = Pazuzu::Supervisor.new(:config_path => @config_path)
+          Signal.trap 'HUP' do
+            @supervisor.load_configuration!
+          end
+          begin
+            @supervisor.run!
+          rescue SystemExit
+          end
+        end
+      end
+
+      def daemonize!(&block)
+        return Process.fork {
+          Process.setsid
+          0.upto(255) do |n|
+            File.for_fd(n, "r").close rescue nil
+          end
+
+          File.umask(27)
+          Dir.chdir('/')
+          $stdin.reopen("/dev/null", 'r')
+          $stdout.reopen("/dev/null", 'w')
+          $stderr.reopen("/dev/null", 'w')
+
+          execute!
+        }
+      end
+
+      def with_pid(&block)
+        path = @pid_path
+        path ||= DEFAULT_PID_PATH
+
+        File.open(path, 'w') do |file|
+          file << Process.pid
+        end
+        begin
+          yield
+        ensure
+          File.delete(path) rescue nil
+        end
+      end
+
+      def prog_name
+        File.basename($0)
+      end
+
+  end
+
+end

data/lib/pazuzu/utility/annotated_logger.rb

@@ -0,0 +1,46 @@
+module Pazuzu
+  module Utility
+
+    # Logger which annotates all log messages.
+    class AnnotatedLogger < SimpleDelegator
+
+      def initialize(logger, prefix)
+        super(logger)
+        @prefix = prefix
+      end
+
+      def debug(message = nil, &block)
+        __getobj__.debug(format_message(message), &block)
+      end
+
+      def info(message = nil, &block)
+        __getobj__.info(format_message(message), &block)
+      end
+
+      def warn(message = nil, &block)
+        __getobj__.warn(format_message(message), &block)
+      end
+
+      def error(message = nil, &block)
+        __getobj__.error(format_message(message), &block)
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        __getobj__.add(severity, format_message(message), progname, &block)
+      end
+
+      private
+
+        def format_message(message)
+          if @prefix.is_a?(Proc)
+            prefix = @prefix.call
+          else
+            prefix = @prefix
+          end
+          "[#{prefix}] #{message}"
+        end
+
+    end
+
+  end
+end

data/lib/pazuzu/utility/output_tailer.rb

@@ -0,0 +1,60 @@
+module Pazuzu
+  module Utility
+
+    class OutputTailer
+
+      def initialize(options = {})
+        @limit = options[:limit] || 1000
+        @callback = options[:on_line] || proc { }
+        @mutex = Mutex.new
+        @buffer = ''
+        @entries = []
+      end
+
+      def open
+        close
+        @stream, writeable_stream = IO.pipe
+        @thread = Thread.start { tail! }
+        return writeable_stream
+      end
+
+      def close
+        if @stream
+          @stream.close rescue nil
+          @stream = nil
+        end
+        if @thread
+          @thread.terminate
+          @thread = nil
+        end
+      end
+
+      def tail!
+        while @stream
+          data = @stream.readpartial(4096)
+          @mutex.synchronize do
+            @buffer << data
+            while @buffer =~ /\A([^\r\n]*)\r?\n(.*)/
+              @buffer = $2
+              add_line!($1)
+            end
+          end
+        end
+      end
+
+      attr_reader :entries
+      attr_reader :limit
+
+      private
+
+        def add_line!(line)
+          pair = [Time.now, line]
+          @entries << pair
+          @entries.shift while @entries.length > @limit
+          @callback.call(pair)
+        end
+
+    end
+
+  end
+end

data/lib/pazuzu/utility/process_spawning.rb

@@ -0,0 +1,40 @@
+module Pazuzu
+  module Utility
+
+    module ProcessSpawning
+
+      def self.prepare_child_process!
+        # Close file handles
+        3.upto(255) do |n|
+          File.for_fd(n, 'r').close rescue nil
+        end
+
+        # Reopen standard file handles
+        $stdin.reopen("/dev/null", 'r')
+        $stdout.reopen("/dev/null", 'w')
+        $stderr.reopen("/dev/null", 'w')
+
+        # Ignore SIGHUP
+        Signal.trap("HUP") { }
+      end
+
+      def self.set_user_and_group!(user, group)
+        current_uid, current_gid = Process.euid, Process.egid
+
+        new_uid = Etc.getpwnam(user).uid if user
+        new_uid ||= current_uid
+        new_gid = Etc.getgrnam(group).gid if group
+        new_gid ||= current_gid
+        if new_uid != current_uid or new_gid != current_gid
+          user_name = user
+          user_name ||= Etc.getpwnam(new_uid).name
+          Process.initgroups(user_name, new_gid)
+          Process::GID.change_privilege(new_gid)
+          Process::UID.change_privilege(new_uid)
+        end
+      end
+  
+    end
+     
+  end
+end

data/lib/pazuzu/utility/rate_limiter.rb

@@ -0,0 +1,68 @@
+module Pazuzu
+  module Utility
+
+    # Simple limiter that can be used to limit the rate of processing. Uses
+    # a short time window to calculate current rate.
+    class RateLimiter
+
+      # Initialize limiter with +max_hertz+ as the maximum frequency per second,
+      # and +window_seconds+ as the number of seconds to calculate frequency
+      # based on.
+      def initialize(max_hertz, window_seconds = 3.0)
+        @max_hertz = max_hertz
+        @history_seconds = window_seconds
+        @window = []
+      end
+
+      # Returns true if current rate exceeds limit.
+      def limited?
+        iterate
+        rate > @max_hertz
+      end
+
+      # Count a cycle. If the current rate exceeds the permitted limit, it will
+      # sleep until the rate goes below the limit. Returns true if not currently
+      # rate-limited, otherwise false.
+      def count!
+        iterate
+        limited = false
+        @window[-1][1] += 1
+        while rate > @max_hertz
+          sleep(0.5)
+          limited = true
+          iterate
+        end
+        !limited
+      end
+
+      # Returns current rate, in hertz.
+      def rate
+        rate = 0
+        window = @window
+        unless window.empty?
+          range = window[-1][0] - window[0][0]
+          if range > 0
+            total = window.inject(0.0) { |sum, (t, count)| sum + count }
+            rate = total / range if total >= @max_hertz
+          end
+        end
+        rate
+      end
+
+      private
+
+        def iterate
+          now = Time.now.to_f.floor
+          window = @window
+          top = window[-1]
+          if !top or top[0] != now
+            window << [now, 0]
+          end
+          time_threshold = now - @history_seconds
+          window.delete_if { |t, count| t < time_threshold }
+        end
+
+    end
+
+  end
+end

data/lib/pazuzu/utility/runnable.rb

@@ -0,0 +1,120 @@
+module Pazuzu
+  module Utility
+
+    # Mixin that provides a state machine for running state.
+    module Runnable
+
+      def initialize
+        _self = self
+        @started_at = nil
+        @stopped_at = nil
+        @state_condition = ConditionVariable.new
+        @mutex = Mutex.new
+        @runnable_state = Statemachine.build do
+          state :stopped do
+            event :start!, :starting
+            on_entry :enter_stopped
+          end      
+          state :starting do
+            event :started!, :running
+            event :failed!, :failed
+            event :stop!, :stopping
+            on_entry :enter_starting
+          end
+          state :running do
+            event :stop!, :stopping
+            event :starting!, :starting
+            on_entry :enter_started
+          end
+          state :stopping do
+            event :stopped!, :stopped
+            on_entry :enter_stopping
+          end
+          state :failed do
+            on_entry :enter_failed
+          end
+          context _self
+        end
+      end
+
+      def start!
+        if [:stopped, :failed].include?(@runnable_state.state)
+          @runnable_state.start!
+        end
+      end
+
+      def stop!
+        if [:starting, :running].include?(@runnable_state.state)
+          @runnable_state.stop!
+        end
+      end
+
+      def run_state
+        @runnable_state.state
+      end
+
+      def wait_for_state_change!
+        @mutex.synchronize { @state_condition.wait(@mutex) }
+      end
+
+      attr_reader :started_at
+      attr_reader :stopped_at
+
+      protected
+
+        attr_reader :runnable_state
+
+        def on_starting
+        end
+
+        def on_started
+        end
+
+        def on_stopping
+        end
+
+        def on_stopped
+        end
+
+        def on_failed
+        end
+
+      private
+
+        def signal_state_change!
+          @mutex.synchronize { @state_condition.signal }
+        end
+
+        def enter_starting
+          signal_state_change!
+          on_starting
+        end
+
+        def enter_started
+          signal_state_change!
+          @stopped_at = nil
+          @started_at = Time.now
+          on_started
+        end
+
+        def enter_stopping
+          signal_state_change!
+          on_stopping
+        end
+
+        def enter_stopped
+          signal_state_change!
+          @stopped_at = Time.now
+          @started_at = nil
+          on_stopped
+        end
+
+        def enter_failed
+          signal_state_change!
+          on_failed
+        end
+
+    end
+
+  end
+end

data/lib/pazuzu/utility/runnable_pool.rb

@@ -0,0 +1,62 @@
+module Pazuzu
+  module Utility
+
+    # Runnable which manages a pool of child runnables that reflect its
+    # parent's running state.
+    class RunnablePool
+
+      include Runnable
+
+      def initialize
+        super
+        @children_mutex = Mutex.new
+        @children = Set.new
+      end
+
+      def length
+        children.length
+      end
+
+      def register(child)
+        raise ArgumentError, 'Child must be runnable' unless child.is_a?(Runnable)
+        @children_mutex.synchronize do
+          @children.add(child)
+        end
+        if [:running, :starting].include?(run_state)
+          child.start!
+        end
+      end
+
+      def unregister(child)
+        if [:running, :starting].include?(child.run_state)
+          child.stop!
+        end
+        @children_mutex.synchronize do
+          @children.delete(child)
+        end
+      end
+
+      def children
+        @children_mutex.synchronize { @children.to_a }
+      end
+
+      protected
+
+        def on_starting
+          @children_mutex.synchronize { @children.dup }.each do |child|
+            child.start!
+          end
+          runnable_state.started!
+        end
+
+        def on_stopping
+          @children_mutex.synchronize { @children.dup }.each do |child|
+            child.stop!
+          end
+          runnable_state.stopped!
+        end
+
+    end
+
+  end
+end