alib 0.3.1 → 0.4.0

data/lib/alib-0.4.0/logging.rb

@@ -0,0 +1,152 @@
+#
+# the logging module extends classes (both at instance and class level) with
+# many methods useful for logging.  it relies on the builtin Logger class
+#
+module ALib::Logging
+#--{{{
+#
+# a module that adds an accessor to Logging objects in ored to fix a bug where
+# not all logging devices are put into sync mode, resulting in improper log
+# rolling.  this is a hack.
+#
+  module LoggerExt
+#--{{{
+    attr :logdev
+    def << *args
+      args.flatten.each{|a| super a}
+      self
+    end
+#--}}}
+  end # module LoggerExt
+#
+# implementations of the methods shared by both classes and objects of classes
+# which include Logging
+#
+  module LogMethods
+#--{{{
+    def __logger_mutex
+#--{{{
+      unless defined?(@__logger_mutex) and @__logger_mutex
+        begin
+          Thread.critical = true
+          @__logger_mutex = Sync::new unless defined?(@__logger_mutex) and @__logger_mutex
+        ensure
+          Thread.critical = false 
+        end
+      end
+      @__logger_mutex
+#--}}}
+    end
+    def __logger_sync
+#--{{{
+      __logger_mutex.synchronize{ yield }
+#--}}}
+    end
+    def logger
+#--{{{
+      return @logger if defined?(@logger)
+      __logger_sync do          
+        unless defined?(@logger)
+          klass = Class === self ? self : self::class
+          self.logger = klass::default_logger 
+        end
+      end
+      @logger
+#--}}}
+    end
+    def logger= log
+#--{{{
+      __logger_sync do          
+        @logger = log
+        @logger.extend LoggerExt
+        @logger.logdev.dev.sync = true rescue nil 
+        @logger
+      end
+#--}}}
+    end
+    %w( debug info warn error fatal ).each do |meth|
+      module_eval <<-code
+        def #{ meth }(*a, &b)
+          __logger_sync{ logger.#{ meth }(*a, &b) }
+        end
+      code
+    end
+    def log_err e
+#--{{{
+      if logger.debug?
+        error{ errmsg e } 
+      else
+        error{ emsg e } 
+      end
+#--}}}
+    end
+    def emsg e
+#--{{{
+      "#{ e.message } - (#{ e.class })"
+#--}}}
+    end
+    def btrace e
+#--{{{
+      e.backtrace.join("\n")
+#--}}}
+    end
+    def errmsg e
+#--{{{
+      emsg(e) << "\n" << btrace(e)
+#--}}}
+    end
+#--}}}
+  end # module LogMethods
+
+  module LogClassMethods
+#--{{{
+    def default_logger
+#--{{{
+      return @default_logger if defined?(@default_logger)
+      __logger_sync do
+        unless defined?(@default_logger)
+          self.default_logger = Logger.new STDERR
+          # @default_logger.warn{ "<#{ self }> using default logger"}
+        end
+      end
+      @default_logger
+#--}}}
+    end
+    def default_logger= log
+#--{{{
+      __logger_sync do
+        @default_logger = (Logger === log ? log : Logger::new(log))
+        @default_logger.extend LoggerExt
+        @default_logger.logdev.dev.sync = true rescue nil
+        @default_logger
+      end
+#--}}}      
+    end
+#--}}}      
+  end   
+
+  EOL    = "\n"
+  DIV0   = ("." * 79) << EOL 
+  DIV1   = ("-" * 79) << EOL 
+  DIV2   = ("=" * 79) << EOL 
+  DIV3   = ("#" * 79) << EOL 
+  SEC0   = ("." * 16) << EOL 
+  SEC1   = ("-" * 16) << EOL 
+  SEC2   = ("=" * 16) << EOL 
+  SEC3   = ("#" * 16) << EOL 
+
+  class << self
+#--{{{
+    def append_features c
+#--{{{
+      ret = super
+      c.extend LogMethods
+      c.extend LogClassMethods
+      ret
+#--}}}
+    end
+#--}}}
+  end
+  include LogMethods
+#--}}}
+end # module Logging

data/lib/alib-0.4.0/main.rb

@@ -0,0 +1,594 @@
+#
+# template main building block classes
+#
+
+
+module ALib
+
+  class AbstractMain
+#--{{{
+    include ALib
+    include ALib::Logging
+
+    EXIT_SUCCESS = 0
+    EXIT_PSEUDO_SUCCESS = 42 
+    EXIT_FAILURE = 1
+
+    class << self
+#--{{{
+      def stringlist(*list)
+#--{{{
+        list.flatten.compact.map{|item| "#{ item }".strip}
+#--}}}
+      end
+      def instance_attributes(*names)
+#--{{{
+        names = stringlist names
+        names.each do |name|
+          getter = "#{ name }"
+          setter = "#{ name }="
+          code = <<-code
+            def #{ name }(*a)
+              unless a.empty?
+                self.#{ name }= a.shift
+              else
+                @#{ name }
+              end
+            end
+            def #{ name }= value
+              @#{ name } = value
+            end
+            alias #{ name }? #{ name }
+          code
+          module_eval code
+        end
+#--}}}
+      end
+      alias instance_attribute instance_attributes
+      alias i_attrs instance_attributes
+      alias i_attr instance_attributes
+      alias attribute instance_attributes
+      alias attributes instance_attributes
+      
+      def class_attributes(*names)
+#--{{{
+        names = stringlist names
+        names.each do |name|
+          getter = "#{ name }"
+          setter = "#{ name }="
+          code = <<-code
+            class << self
+              def #{ name }(*a)
+                unless a.empty?
+                  self.#{ name }= a.shift
+                else
+                  @#{ name }
+                end
+              end
+              def #{ name }= value
+                @#{ name } = value
+              end
+              alias #{ name }? #{ name }
+            end
+          code
+          module_eval code
+        end
+#--}}}
+      end
+      alias class_attribute class_attributes
+      alias c_attrs class_attributes
+      alias c_attr class_attributes
+
+      %w( version author program optspec ).each do |meth|
+#--{{{
+        module_eval <<-code
+          def #{ meth }(*a)
+            unless a.empty?
+              self.#{ meth }= a.shift
+            else
+              @#{ meth }
+            end
+          end
+          def #{ meth }= value
+            @#{ meth } = value
+          end
+          def #{ meth }?
+            defined? @#{ meth } and @#{ meth }
+          end
+        code
+#--}}}
+      end
+      alias prognam program
+      alias prognam= program=
+      alias prognam? program?
+
+      %w( usage examples ).each do |meth|
+#--{{{
+        module_eval <<-code
+          def #{ meth }(*a)
+            unless a.empty?
+              self.#{ meth }= a.shift
+            else
+              @#{ meth }
+            end
+          end
+          def #{ meth }= msg 
+            @#{ meth } = unindent_block msg.to_s
+          end
+          def #{ meth }?
+            defined? @#{ meth } and @#{ meth }
+          end
+        code
+#--}}}
+      end
+
+
+      def unindent_block buf
+#--{{{
+        buf = "#{ buf }"
+        lines = buf.to_a
+        indent_pat = %r/^\s*[\s|]/
+        indent = lines.first[ indent_pat ] rescue nil
+        if indent
+          lines.map do |line| 
+            line[ indent.size..-1 ] || "\n"
+          end.join 
+        else
+          buf 
+        end
+#--}}}
+      end
+
+      def options(*list)
+#--{{{
+        @optspec ||= []
+        return @optspec if list.empty?
+        list = [list] unless Array === list.first
+        list.each{|spec| (@optspec ||= []) << spec}
+#--}}}
+      end
+      alias option options
+
+      def required_arguments(*list)
+#--{{{
+        @required_arguments ||= []
+        list.flatten.each do |arg| 
+          return(optional_argument(arg)) if Hash === arg
+          unless instance_methods.include? "#{ arg }"
+            module_eval <<-code
+              def #{ arg }(*__list)
+                if __list.empty?
+                  @#{ arg }
+                else
+                  send('#{ arg }=', *__list)
+                end
+              end
+              def #{ arg }=(__arg, *__list)
+                if __list.empty?
+                  @#{ arg } = __arg
+                else
+                  @#{ arg } = ([__arg] + __list)
+                end
+              end
+              def #{ arg }?
+                defined? @#{ arg } and @#{ arg }
+              end
+            code
+          end
+          @required_arguments << "#{ arg }"
+        end
+        @required_arguments
+#--}}}
+      end
+      alias required_argument required_arguments
+      alias arguments required_arguments
+      alias argument required_arguments
+
+      def optional_arguments(*list)
+#--{{{
+        @optional_arguments ||= []
+        list.flatten.each do |arg| 
+          arg, default =
+            case arg
+              when Hash
+                arg.to_a.first
+              else
+                [arg, nil]
+            end
+          @do_not_gc ||= [] 
+          @do_not_gc << default unless @do_not_gc.include? default
+          unless instance_methods.include? "#{ arg }"
+            module_eval <<-code
+              def #{ arg }(*__list)
+                unless @#{ arg }
+                  @#{ arg } = ObjectSpace::_id2ref #{ default.object_id }
+                end
+                if __list.empty?
+                  @#{ arg }
+                else
+                  send('#{ arg }=', *__list)
+                end
+              end
+              def #{ arg }=(__arg, *__list)
+                if __list.empty?
+                  @#{ arg } = __arg
+                else
+                  @#{ arg } = ([__arg] + __list)
+                end
+              end
+              def #{ arg }?
+                defined? @#{ arg } and @#{ arg }
+              end
+            code
+          end
+          @optional_arguments << "#{ arg }"
+        end
+        @optional_arguments
+#--}}}
+      end
+      alias optional_argument optional_arguments
+
+      def class_initialize
+#--{{{
+        version '0.0.0'
+
+        author 'ara.t.howard@noaa.gov'
+
+        program File.basename($0)
+
+        optspec [
+          [ '--help', '-h', 'this message' ],
+          [ '--log=path','-l', 'set log file - (default stderr)' ],
+          [ '--verbosity=verbostiy', '-v', '0|fatal < 1|error < 2|warn < 3|info < 4|debug - (default info)' ],
+        ]
+
+        usage <<-usage
+          NAME
+            #{ program } v#{ version }
+
+          SYNOPSIS
+            #{ program } [options]+ [file]+
+        usage
+
+        examples ''
+#--}}}
+      end
+
+      def inherited klass
+#--{{{
+        ret = super
+        klass.class_initialize
+        ret
+#--}}}
+      end
+
+      def run(*a, &b)
+#--{{{
+        new(*a, &b).run
+#--}}}
+      end
+#--}}}
+    end
+
+    class_initialize
+
+    attr :logger
+    attr :program
+    attr :argv
+    attr :env
+    attr :cmdline
+    attr :console
+    attr :options
+    attr :listoptions
+    attr :op
+    attr :logdev
+    attr :verbosity
+    alias console? console
+
+    def initialize argv = ARGV, env = ENV
+#--{{{
+      @argv = Util::mcp(argv.to_a)
+      @env = Util::mcp(env.to_hash)
+      @program = File::expand_path $0
+      @cmdline = ([@program] + @argv).join ' '
+      @console = STDIN.tty?
+#--}}}
+    end
+    def klass; self.class; end
+    def required_arguments
+#--{{{
+      klass::required_arguments
+#--}}}
+    end
+    def optional_arguments
+#--{{{
+      klass::optional_arguments
+#--}}}
+    end
+    def run
+#--{{{
+      logcatch do
+        begin
+          pre_run
+          pre_parse_options
+          parse_options
+          post_parse_options
+          pre_parse_argv
+          parse_argv
+          post_parse_argv
+          init_logging
+          pre_main
+          status = main
+          post_main
+          post_run
+          exit(status ? EXIT_SUCCESS : EXIT_FAILURE)
+        rescue Errno::EPIPE
+          STDOUT.tty? ?  raise : exit(EXIT_FAILURE)
+        end
+      end
+#--}}}
+    end
+    def pre_parse_options; end
+    def post_parse_options; end
+    def pre_parse_argv
+#--{{{
+      if(@options.has_key?('help') or (@argv.size == 1 and @argv.first =~ %r/help/i))
+        usage STDOUT
+        exit EXIT_SUCCESS
+      end
+      if(@options.has_key?('version') or @argv.first =~ %r/version/i)
+        STDOUT.puts self.class.version
+        exit EXIT_SUCCESS
+      end
+#--}}}
+    end
+    def post_parse_argv; end
+    def pre_run; end
+    def post_run; end
+    def pre_main; end
+    def post_main; end
+    def logcatch 
+#--{{{
+      ret = nil
+      @logger ||= Logger::new STDERR
+      begin
+        ret = yield
+      rescue Exception => e
+        unless SystemExit === e
+          fatal{ e }
+          exit EXIT_FAILURE
+        if false
+          if logger.debug?
+            fatal{ e }
+            exit EXIT_FAILURE
+          else
+            fatal{ emsg(e) }
+            exit EXIT_FAILURE
+          end
+        end
+        else
+          exit e.status 
+        end
+      end
+      ret
+#--}}}
+    end
+    def usage port = STDERR
+#--{{{
+      port << klass::usage << "\n" if(klass::usage and not klass::usage.empty?)
+      port << klass::examples << "\n" if(klass::examples and not klass::examples.empty?)
+
+      if klass::optspec 
+        port << 'OPTIONS' << "\n"
+
+        klass::optspec.each do |os| 
+          a, b, c = os
+          long, short, desc = nil
+          [a,b,c].each do |word|
+            next unless word
+            word.strip!
+            case word
+              when %r/^--[^-]/o
+                long = word
+              when %r/^-[^-]/o
+                short = word
+              else
+                desc = word
+            end
+          end
+
+          spec = ((long and short) ? [long, short] : [long])
+
+          if spec
+            port << Util::columnize(spec.join(', '), :width => 80, :indent => 2)
+            port << "\n"
+          end
+
+          if desc
+            port << Util::columnize(desc, :width => 80, :indent => 8)
+            port << "\n"
+          end
+        end
+
+        port << "\n"
+      end
+
+      port
+#--}}}
+    end
+    def parse_options
+#--{{{
+      @op = OptionParser::new
+      @options = {}
+      @listoptions = Hash::new{|h,k| h[k] = []} 
+      klass::optspec.each do |spec|
+        k = spec.first.gsub(%r/(?:--)|(?:=.*$)|(?:\s+)/o,'')
+        @op.def_option(*spec) do |v| 
+          @options[k] = v
+          @listoptions[k] << v
+        end
+      end
+      begin
+        op.parse! @argv 
+      rescue OptionParser::InvalidOption => e
+        # preverve unknown options
+        #e.recover(argv)
+        invalid_option e
+      end
+      @options
+#--}}}
+    end
+    def invalid_option e
+#--{{{
+      # e.recover argv
+      fatal{ e.to_s }
+      exit EXIT_FAILURE
+#--}}}
+    end
+    def init_logging opts = @options 
+#--{{{
+      log = Util::getopt 'log', opts
+      log_age = Util::getopt 'log_age', opts
+      log_size = Util::getopt 'log_size', opts
+      verbosity = Util::getopt 'verbosity', opts
+      log_age = Integer log_age rescue nil
+      log_size = Integer log_size rescue nil
+      $logger = @logger = Logger::new(log || STDERR, log_age, log_size)
+    #
+    # hack to fix Logger sync bug
+    #
+      begin
+        class << @logger; attr :logdev unless @logger.respond_to?(:logdev); end
+        @logdev = @logger.logdev.dev 
+        @logdev.sync = true
+      rescue
+        nil
+      end
+      level = nil
+      verbosity ||= 'info'
+      verbosity =
+        case verbosity
+          when /^\s*(?:4|d|debug)\s*$/io
+            level = 'Logging::DEBUG'
+            4
+          when /^\s*(?:3|i|info)\s*$/io
+            level = 'Logging::INFO'
+            3
+          when /^\s*(?:2|w|warn)\s*$/io
+            level = 'Logging::WARN'
+            2
+          when /^\s*(?:1|e|error)\s*$/io
+            level = 'Logging::ERROR'
+            1
+          when /^\s*(?:0|f|fatal)\s*$/io
+            level = 'Logging::FATAL'
+            0
+          else
+            abort "illegal verbosity setting <#{ verbosity }>" 
+        end
+      @logger.level = 2 - ((verbosity % 5) - 2) 
+      @logger
+#--}}}
+    end
+    def parse_argv
+#--{{{
+      a, b = [], []
+      klass::required_arguments.each do |arg|
+        value = @argv.shift
+        if value 
+          send "#{ arg }=", value
+        else
+          die 'msg' => "required_argument <#{ arg }> not given"
+        end
+        a << send("#{ arg }")
+      end
+      klass::optional_arguments.each do |arg|
+        value = @argv.shift
+        if value 
+          send "#{ arg }=", value
+        end
+        b << send("#{ arg }")
+      end
+      [a, b, @argv]
+#--}}}
+    end
+    def die opts = {} 
+#--{{{
+      msg = Util::getopt 'msg', opts, klass.usage
+      errno = Util::getopt 'errno', opts, EXIT_FAILURE
+      STDERR.puts("#{ msg }")
+      exit(Integer(errno))
+#--}}}
+    end
+    def main 
+#--{{{
+      raise NotImplementedError, 'main'
+#--}}}
+    end
+#--}}}
+  end # class AbstractMain
+
+  class SimpleMain < AbstractMain
+  end
+
+  class ConfigurableMain < AbstractMain
+#--{{{
+    def self.class_initialize
+#--{{{
+      super
+      class_attribute :config_default_path
+      class_attribute :config_search_path
+      class_attribute :configfile
+
+      config_default_path "#{ prognam }.conf"
+
+      config_search_path %w(. ~ /usr/local/etc /usr/etc /etc)
+
+      configfile Class::new(ALib::ConfigFile) #{ default = DATA; DATA.rewind; }
+
+      optspec << [ '--config=path', 'valid path - specify config file (default nil)' ]
+      optspec << [ '--template=[path]', 'valid path - generate a template config file in path (default stdout)' ]
+#--}}}
+    end
+
+    attribute :config
+
+    def pre_parse_argv
+#--{{{
+      super
+      if(@options.has_key?('template') or @argv.first =~ %r/template/i)
+        @argv.shift if @argv.first =~ %r/template/i
+        arg = @argv.first
+        gen_template @options['template'] || @options['config'] || arg
+        exit EXIT_SUCCESS
+      end
+#--}}}
+    end
+    def gen_template template
+#--{{{
+      klass::configfile::gen_template(template)
+      self
+#--}}}
+    end
+    def post_parse_argv
+#--{{{
+      init_config
+#--}}}
+    end
+    def init_config opts = @options
+#--{{{
+      conf = Util::getopt 'config', opts
+      @config =
+        if conf 
+          klass::configfile::new(conf)
+        else
+          klass::configfile::any klass::config_default_path, klass::config_search_path
+        end
+      @config
+#--}}}
+    end
+#--}}}
+  end
+
+end
+