omf_base 1.0

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+.project

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in omf_web.gemspec
+gemspec

data/README.md

@@ -0,0 +1,10 @@
+
+# OMF Base
+
+This GEM contains a few commonly used helper classes used in various places inside the 
+OMF related libraries. This used to be omf_common, but that by now ballooned into something
+much too big for many other tasks.
+
+## Install
+
+    gem install omf_base

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+require "bundler/gem_tasks"
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*_spec.rb"
+  t.verbose = true
+end

data/lib/omf_base/load_yaml.rb

@@ -0,0 +1,90 @@
+
+if $0 == __FILE__
+  module OMF; module Common; end; end
+end
+
+module OMF::Base::YAML
+
+  class YamlFileNotFound < Exception; end
+
+  # A method to load YAML files
+  #
+  # file_name - Name of file to load
+  # opts -
+  # => :default - value to use if file can't be loaded
+  # => :path - array of directories to look for file
+  #
+  # raise YamlFileNotFound if YAML file can't be found
+  #
+  def self.load(file_name, opts = {})
+    if (file_name.split('.').length == 1)
+      file_name = file_name + '.yaml'
+    end
+
+    path = opts[:path] || ['.', File.dirname(__FILE__)]
+    begin
+      path.each do |d|
+        begin
+          return _load_file(d + '/' + file_name)
+        rescue YamlFileNotFound => ex
+        end
+      end
+      if (default = opts[:default])
+        return _symbolize(default)
+      end
+      raise YamlFileNotFound.new("Can't read YAML file '#{file_name}' in '#{path.join(':')}'")
+    end
+  end
+
+  private
+
+  def self._load_file(file, opts = {})
+    begin
+      begin
+        require 'rbyaml'
+        h = RbYAML::load_file(file)
+      rescue LoadError => ex
+        require 'yaml'
+        h = YAML::load_file(file)
+      end
+    rescue Exception => ex
+      unless (h = opts[:default])
+        raise YamlFileNotFound.new("Can't read YAML file '#{file}'")
+      end
+    end
+    _symbolize(h)
+  end
+
+
+  def self._symbolize(obj)
+    if obj.kind_of? Hash
+      res = {}
+      obj.each do |k, v|
+        if k.kind_of? String
+          if k.start_with?(":")
+            k = k[1 .. -1]
+          end
+          k = k.to_sym
+        end
+        res[k] = _symbolize(v)
+      end
+      return res
+    elsif obj.kind_of? Array
+      return obj.collect do |el|
+        _symbolize(el)
+      end
+    else
+      return obj
+    end
+  end
+end
+
+if $0 == __FILE__
+  h = OMF::Base::YAML.load 'foo'#, :default => {':foo' => {:goo=> 3}}
+  puts h.inspect
+  puts h.keys[0].class
+  puts h[:foo].keys[0].class
+
+  #puts OMF::Base::YAML.load('omf-expctl', :path => ['../../../omf-expctl/etc/omf-expctl']).inspect
+
+end

data/lib/omf_base/lobject.rb

@@ -0,0 +1,187 @@
+#
+# Copyright (c) 2006-2009 National ICT Australia (NICTA), Australia
+#
+# Copyright (c) 2004-2009 WINLAB, Rutgers University, USA
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+#
+#
+require 'rubygems'
+require 'date'
+require 'log4r'
+require 'log4r/configurator'
+require 'log4r/yamlconfigurator'
+require 'log4r/outputter/datefileoutputter'
+require 'omf_base/log4r_outputter'
+
+#include Log4r
+
+module OMF; module Base; end end
+
+#
+# An extended object class with support for logging
+#
+module OMF::Base
+  module Loggable
+    @@logger = nil
+    @@rootLoggerName = nil
+
+
+    #
+    # Initialize the logger. The 'appName' is used to build some of the defaults.
+    # The 'environment' is the name of the root
+    # logger. 'AppInstance' and 'appName' are available as parameters
+    # in the log configuration file. The 'opts' hash can optionally
+    # contain information on how to find a configuration file. The
+    # following keys are used:
+    #
+    #  * :environment - Name used for root logger name ['development']
+    #  * :env - Name of environment variable holding dominant config file
+    #  * :fileName - Name of config file [#{appName}_log.xml]
+    #  * :searchPath - Array of directories to look for 'fileName'
+    #
+    def self.init_log(appName, opts = {})
+
+      #@@logger = ::Log4r::Logger.new(appName)
+      set_environment(opts[:environment] || 'development')
+      @@logger = ::Log4r::Logger.new(@@rootLoggerName)
+
+      configFile = opts[:configFile]
+      if (configFile == nil && logEnv = opts[:env])
+          configFile = ENV[logEnv]
+      end
+      if (configFile != nil)
+        # Make sure log exists ...
+        configFile = File.exists?(configFile) ? configFile : nil
+      else
+        name = opts[:fileName] || "#{appName}_log4r.yaml"
+        if ((searchPath = opts[:searchPath]) != nil)
+          searchPath = searchPath.is_a?(Enumerable) ? searchPath : [searchPath]
+          logDir = searchPath.find {|dir|
+            File.exists?("#{dir}/#{name}")
+          }
+          #puts "logDir '#{logDir}:#{logDir.class}'"
+          configFile = "#{logDir}/#{name}" if logDir != nil
+        end
+      end
+      #puts "config file '#{configFile}'"
+      if !(configFile || '').empty?
+        ::Log4r::Configurator['appName'] = appName
+        begin
+          ycfg = YAML.load_file(configFile)
+          ::Log4r::YamlConfigurator.decode_yaml(ycfg['log4r'])
+          #::Log4r::Configurator.load_xml_file(configFile)
+        # rescue ::Log4r::ConfigError => ex
+          # @@logger.outputters = ::Log4r::Outputter.stdout
+          # # TODO: FIX ME
+          # puts("ERROR: Log::Config: #{ex}")
+        end
+      else
+        # set default behavior
+        ::Log4r::Logger.global.level = ::Log4r::ALL
+        formatter = ::Log4r::PatternFormatter.new(:pattern => "%l %c: %m")
+        ::Log4r::StdoutOutputter.new('console', :formatter => formatter)
+        @@logger.add 'console'
+        #@@logger.outputters = ::Log4r::StdoutOutputter.new('console') #Outputter.stdout
+        ##@@logger.outputters = ::Log4r::Outputter.stdout
+      end
+    end
+
+    def self.set_environment(root_logger_name)
+      if root_logger_name.nil? || root_logger_name.empty?
+        # TODO: FIX ME
+        puts("ERROR: LObject: Ignoring empty root logger")
+        return
+      end
+      @@rootLoggerName = root_logger_name
+    end
+
+    def self.logger(category)
+      raise "Logger not initialized" unless @@logger
+
+      name = "#{@@rootLoggerName}::#{category}"
+      logger = Log4r::Logger[name]
+      if logger == nil
+        logger = Log4r::Logger.new(name)
+      end
+      return logger
+    end
+
+    def debug(*message)
+      logger = _logger()
+      logger.debug(message.join('')) if logger.debug?
+    end
+
+    def info(*message)
+      logger = _logger()
+      logger.info(message.join('')) if logger.info?
+    end
+
+    def warn(*message)
+      logger = _logger()
+      logger.warn(message.join('')) if logger.warn?
+    end
+
+    def error(*message)
+      logger = _logger()
+      logger.error(message.join('')) if logger.error?
+    end
+
+    def fatal(*message)
+      logger = _logger()
+      logger.fatal(message.join('')) if logger.fatal?
+    end
+
+    def _logger(category = nil)
+      unless @logger #&& category.nil?
+        cat = self.is_a?(Class) ? self.to_s + 'Class' : self.class.to_s
+        if category
+          cat = "#{cat}-#{category}"
+        end
+        @logger = OMF::Base::Loggable.logger(cat)
+      end
+      return @logger
+    end
+
+  end
+
+  class LObject
+    include Loggable
+    extend Loggable
+
+    def initialize(logCategory = nil)
+      _logger(logCategory)
+    end
+  end
+
+end
+
+if $0 == __FILE__
+  OMF::Base::Loggable.init_log 'foo'
+  #puts OMF::Base::Loggable.logger('test').inspect
+  o = OMF::Base::LObject.new
+  #puts (o.methods - Object.new.methods).sort
+  o.debug 'Something happened'
+
+  o2 = OMF::Base::LObject.new('fancy')
+  o2.debug 'Something happened'
+
+end
+

data/lib/omf_base/log4r_outputter.rb

@@ -0,0 +1,69 @@
+
+
+require 'log4r/outputter/fileoutputter'
+
+module Log4r
+  # When daemonizing, the file handler gets closed and we fall over here. 
+  # The following monkey patch retries once to open the file and write again
+  #
+  class FileOutputter
+    
+    # def initialize(_name, hash={})
+      # raise "#{_name}::#{hash.inspect}"
+    # end
+    
+    def write(data)
+      #puts ">>> #{data}"
+      begin
+        @out.print data
+        @out.flush
+      rescue IOError => ioe # recover from this instead of crash
+        # retry once
+        unless @retrying
+          @retrying = true
+          @out = File.new(@filename, (@trunc ? "w" : "a"))
+          return write(data)
+        end
+        Logger.log_internal {"IOError in Outputter '#{@name}'!"}
+        Logger.log_internal {ioe}
+        close
+      rescue NameError => ne
+        Logger.log_internal {"Outputter '#{@name}' IO is #{@out.class}!"}
+        Logger.log_internal {ne}
+        close
+      end
+      @retrying = false
+    end      
+  end
+end
+
+# module OMF; module Common; end end
+# 
+# #
+# # An extended object class with support for logging
+# #
+# module OMF::Base
+  # module Log4r
+#     
+    # class DateFileOutputter < ::Log4r::DateFileOutputter
+#       
+      # def write(data)
+        # puts ">>> #{data}"
+        # begin
+          # @out.print data
+          # @out.flush
+        # rescue IOError => ioe # recover from this instead of crash
+          # Logger.log_internal {"IOError in Outputter '#{@name}'!"}
+          # Logger.log_internal {ioe}
+          # close
+        # rescue NameError => ne
+          # Logger.log_internal {"Outputter '#{@name}' IO is #{@out.class}!"}
+          # Logger.log_internal {ne}
+          # close
+        # end
+      # end      
+    # end
+  # end
+# end
+# 
+# puts "REQUIRE #{OMF::Base::Log4r::DateFileOutputter}"

data/lib/omf_base/thin/logging.rb

@@ -0,0 +1,54 @@
+require 'omf_base/lobject'
+
+module Thin
+  # Overwrite thin's logging mix-in to work more nicely 
+  # with log4r
+  #
+  module Logging
+    class << self
+      attr_writer :trace, :debug, :silent
+      
+      def trace?;  !@silent && @trace  end
+      def debug?;  !@silent && @debug  end
+      def silent?;  @silent            end
+    end
+    
+    # # Global silencer methods
+    # def silent
+      # Logging.silent?
+    # end
+    # def silent=(value)
+      # Logging.silent = value
+    # end
+    
+    # Log a message to the console
+    def log(msg)
+      (@logger ||= OMF::Base::LObject.new(self.class)).info(msg)
+    end
+    module_function :log
+    public :log
+    
+    # Log a message to the console if tracing is activated
+    def trace(msg=nil)
+      return unless msg      
+      (@logger ||= OMF::Base::LObject.new(self.class)).debug(msg)
+    end
+    module_function :trace
+    public :trace
+    
+    # Log a message to the console if debugging is activated
+    def debug(msg=nil)
+      return unless msg
+      (@logger ||= OMF::Base::LObject.new(self.class)).debug(msg)
+    end
+    module_function :debug
+    public :debug
+    
+    # Log an error backtrace if debugging is activated
+    def log_error(e = $!)
+      (@logger ||= OMF::Base::LObject.new(self.class)).error(e)
+    end
+    module_function :log_error
+    public :log_error
+  end
+end

data/lib/omf_base/thin/runner.rb

@@ -0,0 +1,115 @@
+
+require 'thin'
+require 'omf_base/thin/logging'
+
+#
+# Add code to Thin::Connection to verify peer certificate
+#
+module Thin
+  class Connection
+    def ssl_verify_peer(cert_s)
+      true # will be verified later
+    end
+  end
+end 
+
+module OMF::Base::Thin
+  class Runner < Thin::Runner
+    include OMF::Base::Loggable
+    
+    @@instance = nil
+    
+    def self.instance
+      @@instance
+    end
+  
+    attr_reader :options
+    
+    def initialize(argv, opts = {})
+      raise "SINGLETON" if @@instance
+      
+      @argv = argv
+      sopts = opts.delete(:ssl) # runner has it's own idea of ssl options
+      
+      # Default options values
+      app_name = opts[:app_name] || 'omf_web_app'
+      @options = {
+        :app_name             => app_name,
+        :chdir                => Dir.pwd,
+        :environment          => 'development',
+        :address              => '0.0.0.0',
+        :port                 => Thin::Server::DEFAULT_PORT,
+        :timeout              => Thin::Server::DEFAULT_TIMEOUT,
+        :log                  => "/tmp/#{app_name}_thin.log",
+        :pid                  => "/tmp/#{app_name}.pid",
+        :max_conns            => Thin::Server::DEFAULT_MAXIMUM_CONNECTIONS,
+        :max_persistent_conns => Thin::Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS,
+        :require              => [],
+        :wait                 => Thin::Controllers::Cluster::DEFAULT_WAIT_TIME,
+ 
+        :rackup               => File.dirname(__FILE__) + '/../config.ru',
+        :static_dirs          => ["#{File.dirname(__FILE__)}/../../../share/htdocs"],
+        :static_dirs_pre      => ["./resources"],  # directories to prepend to 'static_dirs'
+        
+        :handlers             => {}  # procs to call at various times of the server's life cycle
+      }.merge(opts)
+      # Search path for resource files is concatination of 'pre' and 'standard' static dirs
+      @options[:static_dirs] = @options[:static_dirs_pre].concat(@options[:static_dirs])
+        
+ 
+ 
+      print_options = false
+      p = parser
+      
+      p.separator ""
+      p.separator "Testing options:"
+      p.on("--disable-https", "Run server without SSL") do sopts = nil end                
+      p.on("--print-options", "Print option settings after parsing command lines args") do print_options = true end                      
+  
+      # Allow application to add it's own parsing options
+      if ph = @options[:handlers][:pre_parse]
+        ph.call(p, @options)
+      end
+      
+      parse!
+
+      if sopts
+        @options[:ssl] = true
+        @options[:ssl_key_file] ||= sopts[:key_file]
+        @options[:ssl_cert_file] ||= sopts[:cert_file]
+        @options[:ssl_verify] ||= sopts[:verify_peer]
+      end
+
+      # Change the name of the root logger so we can apply different logging
+      # policies depending on environment. 
+      #
+      OMF::Base::Loggable.set_environment @options[:environment]
+
+      if print_options
+        require 'pp'
+        pp @options
+      end            
+      
+      @@instance = self
+    end
+    
+    def life_cycle(step)
+      begin
+        if (p = @options[:handlers][step])
+          p.arity == 0 ? p.call() : p.call(@options)
+        end
+      rescue => ex
+        error ex
+        debug "#{ex.backtrace.join("\n")}"
+      end
+    end    
+    
+    def run!
+      life_cycle(:pre_run)
+      super
+    end
+  end
+end
+
+
+  

data/lib/omf_base/version.rb

@@ -0,0 +1,6 @@
+
+module OMF
+  module Base
+    VERSION = '1.0'
+  end
+end

data/omf_base.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "omf_base/version"
+
+Gem::Specification.new do |s|
+  s.name        = "omf_base"
+  s.version     = OMF::Base::VERSION
+  s.authors     = ["NICTA"]
+  s.email       = ["omf-user@lists.nicta.com.au"]
+  s.homepage    = "https://www.mytestbed.net"
+  s.summary     = %q{Some basic, but common functionality used in OMF libraries.}
+  s.description = %q{Some basic, but common functionality used in OMF libraries.}
+
+  s.rubyforge_project = "omf_base"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+#  s.add_development_dependency "minitest", "~> 2.11.3"
+  s.add_runtime_dependency 'log4j'
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: omf_base
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- NICTA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: log4j
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Some basic, but common functionality used in OMF libraries.
+email:
+- omf-user@lists.nicta.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/omf_base.rb
+- lib/omf_base/load_yaml.rb
+- lib/omf_base/lobject.rb
+- lib/omf_base/log4r_outputter.rb
+- lib/omf_base/thin/logging.rb
+- lib/omf_base/thin/runner.rb
+- lib/omf_base/version.rb
+- omf_base.gemspec
+homepage: https://www.mytestbed.net
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: omf_base
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Some basic, but common functionality used in OMF libraries.
+test_files: []