Sutto-perennial 0.1.0

data/lib/perennial/argument_parser.rb

@@ -0,0 +1,60 @@
+require 'shellwords'
+
+module Perennial
+  class ArgumentParser
+    
+    attr_reader :arguments
+    
+    def initialize(array)
+      @raw_arguments = array.dup
+      @arguments     = []
+      @results       = {}
+    end
+    
+    def to_hash
+      @results ||= {}
+    end
+    
+    def parse!
+      while !@raw_arguments.empty?
+        current = @raw_arguments.shift
+        if option?(current)
+          process_option(current, @raw_arguments.first) 
+        else
+          @arguments.push current
+        end
+      end
+      return nil
+    end
+    
+    def self.parse(args = ARGV)
+      parser = self.new(args)
+      parser.parse!
+      return parser.arguments, parser.to_hash
+    end
+    
+    protected
+    
+    def process_option(current, next_arg)
+      name = clean(current)
+      if name.include?("=")
+        real_name, raw_value = name.split("=", 2)
+        @results[real_name] = Shellwords.shellwords(raw_value).join(" ")
+      elsif !(next_arg.nil? || option?(next_arg))
+        @raw_arguments.shift
+        @results[name] = next_arg
+      else
+        @results[name] = true
+      end
+    end
+    
+    def clean(name)
+      name.gsub /^\-+/, ''
+    end
+    
+    def option?(argument)
+      argument.strip =~ /^\-+/
+    end
+    
+  end
+end

data/lib/perennial/core_ext/attribute_accessors.rb

@@ -0,0 +1,129 @@
+# cattr_* and class_inheritable_* are taken from
+# ActiveSupport. Included here to help keep the
+# codebase simple / clean.
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}  # unless defined? @@hair_colors
+          @@#{sym} = nil          #   @@hair_colors = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+                                  #
+        def #{sym}                # def hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+      EOS
+    end
+  end
+ 
+  def cattr_writer(*syms)
+    options = syms.extract_options!
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}                       # unless defined? @@hair_colors
+          @@#{sym} = nil                               #   @@hair_colors = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+      EOS
+    end
+  end
+ 
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+  
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+ 
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar
+        end
+      RUBY
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+ 
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+ 
+      self.send("#{ivar}=", yield) if block_given?
+    end
+  end
+ 
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def class_inheritable_accessor(*syms, &block)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms, &block)
+  end
+  
+end

data/lib/perennial/core_ext/blank.rb

@@ -0,0 +1,51 @@
+# blank? parts taken from the active support source
+# code, used under the MIT License.
+
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def present?
+    !blank?
+  end
+
+end
+ 
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+ 
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+ 
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+ 
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+ 
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+ 
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+ 
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/perennial/core_ext/misc.rb

@@ -0,0 +1,118 @@
+class Object
+
+  def metaclass
+    class << self; self; end
+  end
+
+end
+
+class Inflector
+  class << self
+
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+    
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+    
+  end
+end
+
+module Kernel
+  
+  # From http://oldrcrs.rubypal.com/rcr/show/309
+  def __DIR__(offset = 0)
+    (/^(.+)?:\d+/ =~ caller[offset + 1]) ? File.dirname($1) : nil
+  end
+  
+  # Shorthand for lambda
+  # e.g. L{|r| puts r}
+  def L(&blk)
+    lambda(&blk)
+  end
+  
+  # Shorthand for Proc.new
+  # e.g. P{|r| puts r}
+  def P(&blk)
+    Proc.new(&blk)
+  end
+end
+
+class String
+  def /(*args)
+    File.join(self, *args)
+  end
+  
+  def underscore
+    Inflector.underscore(self)
+  end
+  
+  def camelize(capitalize_first_letter = true)
+    Inflector.camelize(self, capitalize_first_letter)
+  end
+  
+  def to_pathname
+    Pathname.new(self)
+  end
+end
+
+class Array
+  def extract_options!
+    last.is_a?(Hash) ? pop : {}
+  end
+end
+
+class Hash
+  def symbolize_keys
+    hash = self.dup
+    hash.symbolize_keys!
+    return hash
+  end
+  
+  def symbolize_keys!
+    hash = {}
+    self.each_pair { |k,v| hash[k.to_sym] = v }
+    replace hash
+  end
+end
+
+class Module
+  
+  def has_libary(*items)
+    namespace = self.to_s.underscore
+    items.each do |item|
+      require File.join(namespace, item.to_s.underscore)
+    end
+  end
+  
+  def extends_library(*items)
+    namespace = self.to_s.underscore
+    items.each do |item|
+      klass = item.to_s.camelize.to_sym
+      # Load if it isn't loaded already.
+      const_get(klass) unless const_defined?(klass)
+      # And finally load the file.
+      require File.join(namespace, item.to_s.underscore)
+    end 
+  end
+  
+  def attempt_require(*files)
+    files.each do |file|
+      begin
+        require file
+      rescue LoadError
+      end
+    end
+  end
+  
+end

data/lib/perennial/core_ext.rb

@@ -0,0 +1,4 @@
+# Require each individial core extension
+require 'perennial/core_ext/attribute_accessors'
+require 'perennial/core_ext/blank'
+require 'perennial/core_ext/misc'

data/lib/perennial/daemon.rb

@@ -0,0 +1,120 @@
+module Perennial
+  # = Perennial::Daemon provides a relatively simple
+  # interface to creating unix daemons from a given process.
+  # Namely, it focuses on three providing tools for
+  # a couple of simple purposes.
+  #
+  # == Turning a process into a daemon
+  #
+  # This approach is as as simple as calling
+  # Perennial::Daemon.daemonize! - the current process
+  # will then be a daemon, the non-daemon processes
+  # will be killed and if started by the loader, it will
+  # also write a pid out.
+  #
+  # == Checking whether a process is alive
+  #
+  # Perennial::Daemon.alive?(pid) is a super simple way
+  # to check if a pid (as an integer) is current active / alive,
+  # 
+  # Perennial::Daemon.any_alive? takes a type and tells you if
+  # any processes with the associated type are alive.
+  #
+  # == Storing / Retrieving Pids for a Given Loader Type
+  #
+  # Perennial::Daemon.daemonize! will store the pid for
+  # the current process if Perennial::Loader.current_type
+  # is present.
+  #
+  # Perennial::Daemon.any_alive?(type = :all) and
+  # Perennial::Daemon.kill_all(type = :all) can be
+  # used to deal with checking the status of and killing
+  # processes associated with a given loader type.
+  class Daemon
+    class << self
+      
+      def any_alive?(type = :all)
+        !pid_file_for(type).empty?
+      end
+      
+      # Returns true / false depending on whether
+      # a process with the given pid exists.
+      def alive?(pid)
+        return Process.getpgid(pid) != -1
+      rescue Errno::ESRCH
+        return false
+      end
+      
+      # Kills all processes associated with a certain app type.
+      # E.g. Given a loader is starting a :client, kill_all(:client)
+      # would kill all associated processes (usually after daemonizing)
+      # and kill_all would do the same - but if we also started
+      # a process for :server, kill_all(:client wouldn't kill the
+      # the process where as kill_all would.
+      def kill_all(type = :all)
+        kill_all_from(pid_file_for(type))
+        return false
+      end
+      
+      # Converts the current process into a Unix-daemon using
+      # the double fork approach. Also, changes process file
+      # mask to 000 and reopens STDIN / OUT to /dev/null
+      def daemonize!
+        exit if fork
+        Process.setsid
+        exit if fork
+        self.write_pid
+        File.umask    0000
+        STDIN.reopen  "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen STDOUT
+        Perennial::Settings.verbose = false
+      end
+      
+      # Cleans up processes for the current application type
+      # (deteremined by the loader) and then removes the pid file.
+      def cleanup!
+        f = pids_file_for(Loader.current_type)
+        FileUtils.rm_f(f) if (pids_from(f) - Process.pid).blank?
+      end
+      
+      # Returns an array of pid's associated with a given type.
+      def pids_for_type(type)
+        pids_from(pid_file_for(type))
+      end
+      
+      protected
+
+      def kill_all_from(file)
+        pids = pids_from(file)
+        pids.each { |p| Process.kill("TERM", p) unless p == Process.pid }
+        FileUtils.rm_f(file)
+      rescue => e
+        STDOUT.puts e.inspect
+      end
+
+      def pid_file_for(type)
+        type = "*" if type == :all
+        Settings.root / "tmp" / "pids" / "#{type.to_s.underscore}.pid"
+      end
+
+      def pids_from(files)
+        pids = []
+        Dir[files].each do |file|
+          pids += File.read(file).split("\n").map { |l| l.strip.to_i(10) }
+        end
+        return pids.uniq.select { |p| alive?(p) }
+      end
+
+      def write_pid
+        type = Loader.current_type
+        return if type.blank?
+        f = pid_file_for(type)
+        pids = pids_from(f)
+        pids << Process.pid unless pids.include?(Process.pid)
+        File.open(f, "w+") { |f| f.puts pids.join("\n") }
+      end
+      
+    end
+  end
+end

data/lib/perennial/dispatchable.rb

@@ -0,0 +1,110 @@
+module Perennial
+  
+  # = Perennial::Dispatchable
+  # A Generic mixin which lets you define an object
+  # Which accepts handlers which can have arbitrary
+  # events dispatched.
+  # == Usage
+  #
+  #   class X
+  #     include Perennial::Dispatchable
+  #     self.handlers << SomeHandler.new
+  #   end
+  #   X.new.dispatch(:name, {:args => "Values"})
+  #
+  # Will first check if SomeHandler#handle_name exists,
+  # calling handle_name({:args => "Values"}) if it does,
+  # otherwise calling SomeHandler#handle(:name, {:args => "Values"})
+  module Dispatchable
+    
+    def self.handler_mapping
+      @@handler_mapping ||= Hash.new { |h,k| h[k] = [] }
+    end
+    
+    def self.included(parent)
+      parent.class_eval do
+        include InstanceMethods
+        extend  ClassMethods
+      end
+    end
+    
+    module InstanceMethods
+      
+      # Returns the handlers registered on this class,
+      # used inside +dispatch+.
+      def handlers
+        self.class.handlers
+      end
+      
+      # Dispatch an 'event' with a given name to the handlers
+      # registered on the current class. Used as a nicer way of defining
+      # behaviours that should occur under a given set of circumstances.
+      # == Params
+      # +name+: The name of the current event
+      # +opts+: an optional hash of options to pass
+      def dispatch(name, opts = {})
+        # The full handler name is the method we call given it exists.
+        full_handler_name = :"handle_#{name.to_s.underscore}"
+        # First, dispatch locally if the method is defined.
+        self.send(full_handler_name, opts) if self.respond_to?(full_handler_name)
+        # Iterate through all of the registered handlers,
+        # If there is a method named handle_<event_name>
+        # defined we sent that otherwise we call the handle
+        # method on the handler. Note that the handle method
+        # is the only required aspect of a handler. An improved
+        # version of this would likely cache the respond_to?
+        # call.
+        self.handlers.each do |handler|
+          if handler.respond_to?(full_handler_name)
+            handler.send(full_handler_name, opts)
+          else
+            handler.handle name, opts
+          end
+        end
+      # If we get the HaltHandlerProcessing exception, we
+      # catch it and continue on our way. In essence, we
+      # stop the dispatch of events to the next set of the
+      # handlers.
+      rescue HaltHandlerProcessing => e
+        Logger.info "Halting processing chain"
+      rescue Exception => e
+        Logger.log_exception(e)
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      # Return an array of all registered handlers, ordered
+      # by their class and then the order of insertion. Please
+      # note that this will include ALL handlers up the inheritance
+      # chain unless false is passed as the only argument.
+      def handlers(recursive = true)
+        handlers = []
+        if recursive && superclass.respond_to?(:handlers)
+          handlers += superclass.handlers(recursive)
+        end
+        handlers += Dispatchable.handler_mapping[self]
+        return handlers
+      end
+      
+      # Assigns a new array of handlers and assigns each - Note that
+      # this will only set this classes handlers, it will not override
+      # those for others above / below it in the inheritance chain.
+      def handlers=(new_value)
+        Dispatchable.handler_mapping.delete self
+        [*new_value].each { |h| register_handler h }
+      end
+      
+      # Appends a handler to the list of handlers for this object.
+      # Handlers are called in the order they are registered.
+      def register_handler(handler)
+        unless handler.blank? || !handler.respond_to?(:handle)
+          Dispatchable.handler_mapping[self] << handler 
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/perennial/exceptions.rb

@@ -0,0 +1,6 @@
+module Perennial
+  # General Perennial exceptions.
+  class Error < StandardError;         end
+  # Called to halt handler processing.
+  class HaltHandlerProcessing < Error; end
+end

data/lib/perennial/hookable.rb

@@ -0,0 +1,63 @@
+module Perennial
+  # = Perennial::Hookable
+  # 
+  # Perennial::Hookable provides a generic set of functionality
+  # for implementing simple block-based hooks / callbacks. On
+  # a class level, this makes it easy for you to do event driven
+  # programming in that code can be registered to be run
+  # when something happens.
+  #
+  # Hookable differs from Perennial::Dispatchable in that it is
+  # designed to be lightweight / used for things like setting things
+  # up without all of the overhead of defining handlers / dispatching
+  # messages.
+  module Hookable
+    
+    def self.included(parent)
+      parent.class_eval do
+        extend ClassMethods
+        cattr_accessor :hooks
+        self.hooks = Hash.new { |h,k| h[k] = [] }
+      end
+    end
+    
+    module ClassMethods
+      
+      # Append a hook for a given type of hook in order
+      # to be called later on via invoke_hooks!
+      def append_hook(type, &blk)
+        self.hooks_for(type) << blk unless blk.blank?
+      end
+
+      # Return all of the existing hooks or an empty
+      # for a given hook type.
+      def hooks_for(type)
+        self.hooks[type.to_sym]
+      end
+
+      # Invoke (call) all of the hooks for a given
+      # type.
+      def invoke_hooks!(type)
+        hooks_for(type).each { |hook| hook.call }
+      end
+      
+      # Defines a set of handy methods to make it
+      # easy to define simplistic block based hooks
+      # on an arbitrary class.
+      def define_hook(*args)
+        klass = self.metaclass
+        args.map { |a| a.to_sym }.each do |name|
+          
+          klass.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{name}(&blk)               # def before_run(&blk)
+              append_hook(:#{name}, &blk)   #   append_hook(:before_run, &blk)
+            end                             # end
+          RUBY
+          
+        end
+      end
+      
+    end
+    
+  end
+end