patriot-workflow-scheduler 0.6.1

data/lib/patriot/util/db_client.rb

@@ -0,0 +1,65 @@
+require 'patriot/util/db_client/base'
+require 'patriot/util/db_client/record'
+require 'patriot/util/db_client/hash_record'
+
+module Patriot
+  module Util
+    # name space for connectors of RDBs
+    module DBClient
+
+      # a set of configuration keys for the connectors
+      DB_CONFIG_KEYS = ["adapter", 
+                        "database", 
+                        "host", 
+                        "port", 
+                        "username", 
+                        "password", 
+                        "encoding", 
+                        "pool"]
+
+      # read DB configuration from a given config
+      # @param prefix [String] a prefix for DB configuration key
+      # @param config [Patriot::Util::Config::Base] configuration
+      def read_dbconfig(prefix, config)
+        db_config = {}
+        Patriot::Util::DBClient::DB_CONFIG_KEYS.each do |k|
+          v = config.get([prefix,k].join("."))
+          db_config[k.to_sym] = v
+        end
+        return db_config
+      end
+
+      # get connection to db.
+      # if block is given, call the given block and close the connection
+      # @param dbconf [Hash]
+      #   configuration for database
+      #   type of database should be set with key :adapter
+      # @yield
+      #   block executed with a connection to the database. 
+      #   the connection is passed to the block as a argument
+      # @yieldparam [Patriot::Util::DBClient::Base] a connection to db
+      def connect(dbconf, &blk)
+        client = get_db_client(dbconf)
+        return client unless block_given?
+        begin 
+          return yield client
+        rescue Exception => e
+          raise e
+        ensure 
+          client.close
+        end
+      end
+
+      # @private
+      # @return [Patriot::Util::DBClient::Base]
+      def get_db_client(dbconf = {})
+        raise "no adapter is specified" unless dbconf.has_key?(:adapter)
+        adapter = dbconf[:adapter].to_sym
+        raise "no builder method is registered for #{adapter}" unless self.respond_to?(adapter)
+        return self.send(adapter, dbconf)
+      end
+      private :get_db_client
+
+    end
+  end
+end

data/lib/patriot/util/db_client/base.rb

@@ -0,0 +1,142 @@
+module Patriot module Util
+    module DBClient
+
+      # @abstract base class for DB connection
+      class Base
+
+        # close this connection
+        def close()
+          raise NotImplementedError
+        end
+
+        # execute a given statment with this connection.
+        # @param [String] stmt SQL statement to be executed
+        # @param [Symbol] type type of execution (return type)
+        # @return [Array] a list of records if the type is :select
+        # @return [Integer] a id of last inserted record if the type is :insert
+        # @return [Integer] the nubmer of affected rows if the type is :update
+        def execute_statement(stmt, type = :select)
+          method = "do_#{type}".to_sym
+          begin
+            return self.send(method, stmt)
+          rescue => e
+            raise "Failed to execute #{stmt} : Caused by (#{e})" 
+          end
+        end
+
+        # insert value into a given table
+        # @param [String] tbl the name of table where a row will be inserted
+        # @param [Hash] value a Hash represents the inserted value
+        # @param [Hash] opts
+        # @option [Boolean] :ignore set true if set conflict strategy IGNORE (default false)
+        # @return [Integer] a id of the last inserted record
+        # @example the below invocation issues "INSERT INTO table (col) VALUES ('val')"
+        #   insert('table', {:col => 'val'})
+        def insert(tbl, value, opts = {})
+          query = build_insert_query(tbl, value, opts)
+          return execute_statement(query, :insert)
+        end
+
+        # create a insert statement for given arguments.
+        # Subclasses can override this method if necessary
+        # @param [String] tbl the name of table where a row will be inserted
+        # @param [Hash] value a Hash represents the inserted value
+        # @param [Hash] opts
+        # @option [Boolean] :ignore set true if set conflict strategy IGNORE (default false)
+        # @return [String] insert statement expression
+        def build_insert_query(tbl, value, opts = {})
+          opts = {:ignore => false}.merge(opts)
+          cols, vals = [], []
+          value.each do |c,v|
+            cols << c
+            vals << quote(v)
+          end
+          return "INSERT INTO #{tbl} (#{cols.join(',')}) VALUES (#{vals.join(',')})"
+        end
+
+        # The method which issues an insert statement
+        # @param [String] query an insert statement
+        # @return [Integer] a id of last inserted record if the type is :insert
+        def do_insert(query)
+          raise NotImplementedError
+        end
+
+        # select records from a table
+        # @param [String] tbl the name of table where the records are searched
+        # @param [Hash] cond a set of conditons for each attributes
+        # @param [Hash] opts
+        # @option [Integer] :limit LIMIT nubmer
+        # @option [Integer] :offset OFFSET nubmer
+        # @option [ARRAY] :items a list of output items
+        # @return [Array] a list of records
+        # @example the below invocation issues "SELECT * FROM table WHERE col = 'val'"
+        #   select('table', {:col => 'val'})
+        def select(tbl, cond = {}, opts = {})
+          opts  = {:items => ['*']}.merge(opts)
+          query = "SELECT #{opts[:items].join(', ')} FROM #{tbl} #{cond_exp(cond)}"
+          query = "#{query} LIMIT #{opts[:limit]}" if opts.has_key?(:limit)
+          query = "#{query} OFFSET #{opts[:offset]}" if opts.has_key?(:offset)
+          return execute_statement(query, :select)
+        end
+
+        # The method which issues a select statement
+        # @param [String] query a select statement
+        # @return [Array] a list of records
+        def do_select(query)
+          raise NotImplementedError
+        end
+
+        # delete records from a table
+        # @param [String] tbl the name of table from which records are deleted
+        # @param [Hash] cond a set of conditions on deleted records
+        # @return [Integer] the nubmer of affected rows
+        # @example the below invocation issues "DELETE FROM table WHERE col = 'val'"
+        #   delete('table', {:col => 'val'})
+        def delete(tbl, cond)
+          query = "DELETE FROM #{tbl} #{cond_exp(cond)}"
+          return execute_statement(query, :update)
+        end
+
+        # update records of a table
+        # @param [String] tbl the name of table in which records are updated
+        # @param [Hash] new_val a set of new values
+        # @param [Hash] cond a set of conditions on update records
+        # @return [Integer] the nubmer of affected rows
+        # @example the below invocation issues "UPDATE table SET col = 'val2' WHERE col = 'val1'"
+        #   update('table', {:col => 'val2'}, {:col => 'val1'})
+        def update(tbl, new_val, cond)
+          query = "UPDATE #{tbl} SET #{value_exp(new_val)} #{cond_exp(cond)}"
+          return execute_statement(query, :update)
+        end
+
+        # The method which issues a delete/update statement
+        # @param [String] query a delete/update statement
+        # @return [Integer] the nubmer of affected rows
+        def do_update(query)
+          raise NotImplementedError
+        end
+
+        # get an expression used as values in insert statements
+        def value_exp(val)
+          raise "illegal type of value_exp #{val.class}" unless val.is_a?(Hash)
+          return val.map{|k,v| v.nil? ? "#{k} = NULL" : "#{k} = #{quote(v)}"}.join(",")
+        end
+
+        # get an expression of where clause
+        def cond_exp(cond)
+          cond = cond.map{|k,v| v.nil? ? "#{k} IS NULL" : "#{k} = #{quote(v)}"}.join(' AND ') if cond.is_a?(Hash)
+          raise "illegal type of cond : #{cond.class}" unless cond.is_a?(String)
+          cond = "WHERE #{cond}" unless cond == ""
+          return cond
+        end
+
+        # quote a given value to use in SQL
+        def quote(v)
+          raise NotImplementedError
+        end
+
+      end
+
+    end
+  end
+end

data/lib/patriot/util/db_client/hash_record.rb

@@ -0,0 +1,53 @@
+
+module Patriot
+  module Util
+    module DBClient
+
+      # a record implementation based on Hash
+      class HashRecord < Patriot::Util::DBClient::Record
+
+        # @param record [Hash]
+        def initialize(record)
+          @record = {}
+          # ignore fixnum which is not column name
+          record.each{|k,v| @record[k.to_sym] =  v unless k.is_a?(Fixnum)}
+        end
+
+        # @see Patriot::Util::DBClient::Record#get_id
+        def get_id
+          return @record[:id]
+        end
+
+        # @see Patriot::Util::DBClient::Record#to_mash
+        def to_hash(keys = @record.keys)
+          hash = {}
+          keys.each{|k| hash[k] = @record[k]}
+          return hash
+        end
+
+        # used as accessors
+        def method_missing(mth, *args, &blk)
+          key = mth
+          type = :get
+          if key.to_s.end_with?("=")
+            key = key.to_s.slice(0..-2).to_sym
+            type = :set
+          end
+
+          if type == :get
+            if @record.has_key?(mth)
+              return @record[mth] 
+            else
+              return nil
+            end
+          elsif type == :set
+            @record[key] = args[0]
+            return
+          end
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/patriot/util/db_client/record.rb

@@ -0,0 +1,25 @@
+
+module Patriot
+  module Util
+    module DBClient
+
+      # a class for abstracting access to records
+      # sub classes of this class should provide accessers for columns or select items
+      # (e.g. overwrite method_missing)
+      class Record
+
+        # get serial id of this record
+        def get_id
+          raise NotImplementedError
+        end
+
+        # convert this record to hash 
+        # @param keys [Hash] attributes included in the returned hash
+        def to_hash(keys)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end
+

data/lib/patriot/util/logger.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'log4r'
+
+require 'patriot/util/logger/facade'
+require 'patriot/util/logger/factory'
+require 'patriot/util/logger/log4r_factory'
+require 'patriot/util/logger/webrick_log_factory'
+
+module Patriot
+  module Util
+    # logger namespace
+    module Logger
+      include Patriot::Util::Config
+
+      # create logger based on a given configration
+      # @param conf [Patriot::Util::Config::Base]
+      def create_logger(conf)
+        name    = self.class.to_s
+        @logger = Patriot::Util::Logger::Factory.create_logger(name, conf)
+      end
+
+    end
+  end
+end

data/lib/patriot/util/logger/facade.rb

@@ -0,0 +1,33 @@
+module Patriot
+  module Util
+    module Logger
+      # facade class for loggers
+      class Facade
+        # supported log levels
+        LEVELS = [:debug, :info, :warn, :error, :fatal]
+
+        # @param logger [Object] logger hidden in this facade
+        def initialize(logger)
+          @logger = logger
+        end
+
+        LEVELS.each do |lvl|
+          define_method(lvl) do |msg|
+            if msg.is_a? Exception
+              @logger.send(lvl, msg.message)
+              msg.backtrace.each{|bt| @logger.send(lvl, bt)}
+            else
+              @logger.send(lvl, msg)
+            end
+          end
+        end
+
+        # for Rack::CommonLogger
+        def write(msg)
+          @logger.info(msg)
+        end
+      end
+    end
+  end
+end
+

data/lib/patriot/util/logger/factory.rb

@@ -0,0 +1,59 @@
+require 'thread'
+module Patriot
+  module Util
+    module Logger
+
+      # logger factory
+      class Factory
+        # configuration key for logger factory class
+        FACTORY_CLASS_KEY = :log_factory
+
+        # default logger factory class
+        DEFAULT_LOGGER_FACTORY_CLASS = 'Patriot::Util::Logger::Log4rFactory'
+
+        # @param name [String] logger name
+        # @param config [Patriot::Util::Config::Base] configuration
+        # @return [Patriot::Util::Logger::Facade]
+        def self.create_logger(name, config)
+          klass = get_factory_class_name(config)
+          # implentations of logger facotory should include Singleton
+          logger = eval(klass).instance.get_logger(name, config)
+          return logger
+        end
+
+        # @param config [Patriot::Util::Config::Base]
+        # @return [String] factory class name
+        def self.get_factory_class_name(config)
+          return config.get(FACTORY_CLASS_KEY, DEFAULT_LOGGER_FACTORY_CLASS).to_s
+        end
+
+        def initialize
+          @mutex   = Mutex.new
+          @loggers = {}
+        end
+
+        # @param name [String] logger name
+        # @param config [Patriot::Util::Config::Base] configuration
+        # @return [Patriot::Util::Logger::Facade]
+        def get_logger(name, config)
+          @mutex.synchronize do
+            unless @loggers.has_key?(name)
+              logger = build(name,config)
+              @loggers[name] = Facade.new(logger)
+            end
+            return @loggers[name]
+          end
+        end
+
+        # build logger
+        # should be overridden in sub-classes
+        # @param name [String] logger name
+        # @param config [Patriot::Util::Config::Base] configuration
+        def build(name, config)
+          raise NotImplementedError
+        end
+
+      end
+    end
+  end
+end

data/lib/patriot/util/logger/log4r_factory.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+require 'log4r'
+require 'log4r/outputter/datefileoutputter'
+require 'patriot/util/logger/factory'
+require 'singleton'
+
+module Patriot
+  module Util
+    module Logger
+      # a logger factory implementation for Log4r logger
+      class Log4rFactory < Patriot::Util::Logger::Factory
+        # configuration key for log level
+        LOG_LEVEL_KEY  = :log_level
+        # default log level
+        DEFAULT_LOG_LEVEL = 'DEBUG'
+        # configuration key for log format
+        FORMAT_KEY     = :log_format
+        # default log format
+        DEFAULT_LOG_FORMAT = '%m'
+        # configuration key for log outputers
+        OUTPUTTERS_KEY = :log_outputters
+        # configuration prefix for log outputer
+        OUTPUTTER_KEY_PREFIX = :log_outputter
+
+        include Singleton
+
+        # @see Patriot::Util::Logger:Factory
+        def build(name, config)
+          logger  = Log4r::Logger.new(name)
+          logger  = set_log_level(logger, config)
+          logger  = set_outputters(logger, config)
+          return logger
+        end
+        private :build
+
+        # set log level to the logger
+        def set_log_level(logger, config)
+          log_level    = get_log_level(config)
+          logger.level = log_level
+          return logger
+        end
+        private :set_log_level
+
+        # set outputters to the logger
+        def set_outputters(logger, config)
+          formatter   = create_formatter(config)
+          logger.outputters = get_outputters(config, formatter)
+          return logger
+        end
+        private :set_outputters
+
+        # create formatter based on the configuration
+        def create_formatter(config)
+          log_format = get_format_config(config)
+          formatter  = Log4r::PatternFormatter.new(:pattern => log_format)
+          return formatter
+        end
+        private :set_outputters
+
+        # @private
+        def get_log_level(_conf)
+          log_level = _conf.get(LOG_LEVEL_KEY, DEFAULT_LOG_LEVEL)
+          log_level = eval("Log4r::#{log_level}")
+          return log_level
+        end
+        private :get_log_level
+
+        # @private
+        def get_format_config(_conf)
+          return _conf.get(FORMAT_KEY, DEFAULT_LOG_FORMAT)
+        end
+        private :get_format_config
+
+        # @private
+        def get_outputters(_conf, _formatter)
+          outputters = _conf.get(OUTPUTTERS_KEY, [])
+          outputters = [outputters] unless outputters.is_a?(Array)
+          return outputters.map{|o| get_outputter(o, _conf, _formatter)}
+          return outputters
+        end
+        private :get_outputters
+
+        # @private
+        def get_outputter(outputter_id, _conf, _formatter)
+          class_key = [OUTPUTTER_KEY_PREFIX, outputter_id, "class"].join(".") 
+          class_name = _conf.get(class_key)
+          raise "logger class: #{class_key} is not set" if class_name.nil?
+          outputter = nil
+          case class_name
+          when "Log4r::StdoutOutputter"
+            outputter = Log4r::Outputter.stdout
+          when "Log4r::StderrOutputter"
+            outputter = Log4r::Outputter.stderr
+          when "Log4r::DateFileOutputter" 
+            dir_key = [OUTPUTTER_KEY_PREFIX, outputter_id, "dir"].join(".") 
+            file_key = [OUTPUTTER_KEY_PREFIX, outputter_id, "file"].join(".") 
+            outputter = Log4r::DateFileOutputter.new("file", :filename => _conf.get(file_key), :dirname => _conf.get(dir_key))
+          else
+            raise "unsupported outputter #{klass}"
+          end
+          # TODO to set outputter-specific formatter 
+          outputter.formatter = _formatter
+          return outputter
+        end
+        private :get_outputter
+
+      end
+    end
+  end
+end
+