libis-tools 1.0.5-java

data/lib/libis/tools/command.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+require 'timeout'
+
+module Libis
+  module Tools
+
+    # This module allows to run an external command safely and returns it's output, error messages and status.
+    # The run method takes any number of arguments that will be used as command-line arguments. The method returns
+    # a Hash with:
+    # * :out => an array with lines that were printed on the external program's standard out.
+    # * :err => an array with lines that were printed on the external program's standard error.
+    # * :status => exit code returned by the external program.
+    # * :timeout => true if the command was terminated due to a timeout.
+    # * :pid => pid of the command (in case <pid>.log files need to be cleaned up)
+    #
+    # Optionally an option hash can be appended to the list of arguments with:
+    # * :stdin_data => values sent to the command's standard input (optional, nothing sent if not present)
+    # * :binmode => if present and true, will set the IO communication to binary data
+    # * :timeout => if specified, SIGTERM signal is sent to the command after the number of seconds
+    # * :signal => Signal sent to the command instead of the default SIGTERM
+    # * :kill_after => if specified, SIGKILL signal is sent aftern the number of seconds if command is still running
+    #             after initial signal was sent
+    # * any other options will be handed over to the spawn command (e.g. pgroup)
+    #
+    # Examples:
+    #
+    #     require 'libis/tools/command'
+    #     result = ::Libis::Tools::Command.run('ls', '-l', File.absolute_path(__FILE__))
+    #     p result # => {out: [...], err: [...], status: 0}
+    #
+    #     require 'libis/tools/command'
+    #     include ::Libis::Tools::Command
+    #     result = run('ls', '-l', File.absolute_path(__FILE__))
+    #     p result # => {out: [...], err: [...], status: 0}
+    #
+    # Note that the Command class uses Open3#popen3 internally. All arguments supplied to Command#run are passed to
+    # the popen3 call. Unfortunately some older JRuby versions have some known issues with popen3. Please use and
+    # test carefully in JRuby environments.
+    module Command
+
+      # Run an external program and return status, stdout and stderr.
+      #
+      #
+      # @param [Array<String>] cmd command name optionally prepended with env and appended with command-line arguments
+      # @return [Hash] a Hash with:
+      #         * :status (Integer) - the exit status of the command
+      #         * :out (Array<String>) - the stdout output of the command
+      #         * :err (Array<String>)- the stderr output of the command
+      #         * :timeout(Boolean) - if true, the command did not return in time
+      #         * :pid(Integer) - the command's processID
+      def self.run(*cmd)
+
+        spawn_opts = Hash === cmd.last ? cmd.pop.dup : {}
+        opts = {
+            :stdin_data => spawn_opts.delete(:stdin_data) || '',
+            :binmode => spawn_opts.delete(:binmode) || false,
+            :timeout => spawn_opts.delete(:timeout),
+            :signal => spawn_opts.delete(:signal) || :TERM,
+            :kill_after => spawn_opts.delete(:kill_after),
+        }
+        in_r, in_w = IO.pipe
+        out_r, out_w = IO.pipe
+        err_r, err_w = IO.pipe
+        in_w.sync = true
+
+        if opts[:binmode]
+          in_w.binmode
+          out_r.binmode
+          err_r.binmode
+        end
+
+        spawn_opts[:in] = in_r
+        spawn_opts[:out] = out_w
+        spawn_opts[:err] = err_w
+
+        result = {
+            :pid => nil,
+            :status => nil,
+            :out => [],
+            :err => [],
+            :timeout => false,
+        }
+
+        out_reader = nil
+        err_reader = nil
+        wait_thr = nil
+
+        begin
+          Timeout.timeout(opts[:timeout]) do
+            result[:pid] = spawn(*cmd, spawn_opts)
+            wait_thr = Process.detach(result[:pid])
+            in_r.close
+            out_w.close
+            err_w.close
+
+            out_reader = Thread.new {out_r.read}
+            err_reader = Thread.new {err_r.read}
+
+            in_w.write opts[:stdin_data]
+            in_w.close
+
+            result[:status] = wait_thr.value
+          end
+
+        rescue Timeout::Error
+          result[:timeout] = true
+          pid = spawn_opts[:pgroup] ? -result[:pid] : result[:pid]
+          Process.kill(opts[:signal], pid)
+          if opts[:kill_after]
+            unless wait_thr.join(opts[:kill_after])
+              Process.kill(:KILL, pid)
+            end
+          end
+
+        rescue StandardError => e
+          result[:err] = [e.class.name, e.message]
+
+        ensure
+          result[:status] = wait_thr.value.exitstatus if wait_thr
+          result[:out] += out_reader.value.split("\n").map(&:chomp) if out_reader
+          result[:err] += err_reader.value.split("\n").map(&:chomp) if err_reader
+          out_r.close unless out_r.closed?
+          err_r.close unless err_r.closed?
+        end
+
+        result
+
+      end
+
+    end
+
+  end
+end

data/lib/libis/tools/command_line.rb

@@ -0,0 +1,23 @@
+require 'thor'
+require 'tty-prompt'
+require 'tty-config'
+
+require 'libis/tools/cli/cli_helper'
+require 'libis/tools/cli/reorg'
+
+module Libis
+  module Tools
+
+    class CommandLine < Thor
+
+      include Cli::Helper
+      include Cli::Reorg
+
+      def reorg
+        super
+      end
+
+    end
+
+  end
+end

data/lib/libis/tools/config.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+require 'singleton'
+require 'yaml'
+require 'erb'
+require 'logging'
+
+require_relative 'config_file'
+
+module Libis
+  module Tools
+
+    # The Singleton Config class is a convenience class for easy configuration maintenance, loading and saving.
+    # It also initializes a default logger and supports creating extra loggers. The logging infrastructure is based on
+    # the {http://www.rubydoc.info/gems/logging/Logging ::Logging} gem and supports the {::Libis::Tools::Logger} class.
+    #
+    # For the configuration parameters, it supports code defaults, loading configurations from multiple YAML files
+    # containing ERB statements. The Config class behaves like a Hash/OpenStruct/HashWithIndifferentAccess.
+    #
+    # The parameters can be accessed by getter/setter method or using the Hash syntax:
+    #
+    #         require 'libis/tools/config'
+    #         cfg = ::Libis::Tools::Config
+    #         cfg['my_value'] = 10
+    #         p cfg.instance.my_value # => 10
+    #         cfg.instance.my_text = 'abc'
+    #         p cfg[:my_text] # => 'abc'
+    #         p cfg.logger.warn('message') # => W, [2015-03-16T12:51:01.180548 #123.456]  WARN : message
+    #
+    class Config
+      include Singleton
+
+      class << self
+
+        private
+
+        # For each configuration parameter, the value can be accessed via the class or the Singleton instance.
+        # The class diverts to the instance automatically.
+        def method_missing(name, *args, &block)
+          result = instance.send(name, *args, &block)
+          self === result ? self : result
+        end
+
+      end
+
+      # Instance method that allows to access the configuration parameters by method.
+      def method_missing(name, *args, &block)
+        result = config.send(name, *args, &block)
+        self === config ? self : result
+      end
+
+      # Load configuration parameters from a YAML file or Hash.
+      #
+      # The file paths and Hashes are memorised and loaded again by the {#reload} methods.
+      # @param [String,Hash] file_or_hash
+      def <<(file_or_hash)
+        sync do
+          @config.send('<<', (file_or_hash)) { |data| @sources << data }
+          self
+        end
+      end
+
+      # Load all files and Hashes again.
+      #
+      # Will not reset the configuration parameters. Parameters set directly on the
+      # configuration are kept intact unless they also exist in the files or hashes in which case they will be overwritten.
+      def reload
+        sync do
+          sources = @sources.dup
+          @sources.clear
+          sources.each { |f| self << f }
+          self
+        end
+      end
+
+      # Clear data and load all files and Hashes again.
+      #
+      # All configuration parameters are first deleted which means that any parameters
+      # added directly (not via file or hash) will no longer be available. Parameters set explicitly that also exist in
+      # the files or hashes will be reset to the values in those files and hashes.
+      def reload!
+        sync do
+          @config.clear!
+          reload
+        end
+      end
+
+      # Clear all data.
+      #
+      # Not only all configuration parameters are deleted, but also the memorized list of loaded files
+      # and hashes are cleared and the logger configuration is reset to it's default status.
+      def clear!
+        sync do
+          @config.clear!
+          @sources = Array.new
+          self.logger
+          self
+        end
+      end
+
+      # Gets the default ::Logging formatter.
+      #
+      # This in an instance of a layout that prints in the default message format.
+      #
+      # The default layout prints log lines like this:
+      #
+      #     <first char of severity>, [<timestamp> #<process-id>.<thread-id] <severity> : <message>
+      #
+      def get_log_formatter
+        # noinspection RubyResolve
+        ::Logging::Layouts::Pattern.new(DEFAULT_LOG_LAYOUT_PARAMETERS)
+      end
+
+      def logger(name = nil, appenders = nil)
+        sync do
+          name ||= 'root'
+          logger = ::Logging.logger[name]
+          if logger.appenders.empty?
+            logger.appenders = appenders || ::Logging.appenders.stdout(layout: get_log_formatter)
+          end
+          logger
+        end
+      end
+
+      attr_accessor :config, :sources
+
+      protected
+
+      def initialize(hash = nil, opts = {})
+        @mutex = ReentrantMutex.new
+        @config = ConfigFile.new(hash, opts)
+        self.clear!
+      end
+
+      def sync(&block)
+        @mutex.synchronize(&block)
+      end
+
+      ::Logging::init
+      # noinspection RubyResolve
+      DEFAULT_LOG_LAYOUT_PARAMETERS = {
+          pattern: "%.1l, [%d #%p.%t] %5l%X{Application}%X{Subject} : %m\n",
+          date_pattern: '%Y-%m-%dT%H:%M:%S.%L'
+      }
+
+    end
+  end
+end

data/lib/libis/tools/config_file.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+require 'singleton'
+require 'yaml'
+require 'erb'
+
+require 'libis/tools/deep_struct'
+
+module Libis
+  module Tools
+
+    # The ConfigFile class is a convenience class for interfacing with YAML configuration files. These files can
+    # contain ERB statements. An initial hash or file can be loaded during initialization. The class supports loading
+    # and saving of files, but note that any ERB statements in the file are lost by performing such a round trip.
+    # The class is derived from the DeepStruct class and therefore supports nested hashes and arrays and supports
+    # the OpenStruct style of accessors.
+    #
+    # The parameters can be accessed by getter/setter method or using the Hash syntax:
+    #
+    #         require 'libis/tools/config_file'
+    #         cfg_file = ::Libis::Tools::ConfigFile.new
+    #         cfg_file << {foo: 'bar'}
+    #         cfg_file.my_value = 10
+    #         p cfg_file[:my_value] # => 10
+    #         cfg_file{:my_text] = 'abc'
+    #         p cfg_file['my_text'] # => 'abc'
+    #         p cfg_file.to_hash # => { :foo => 'bar', 'my_value' => 10, :my_text => 'abc' }
+    #         cfg >> 'my_config.yml'
+    #
+    class ConfigFile < DeepStruct
+
+      # Create a new ConfigFile instance. The optional argument can either be a Hash or a String. The argument is
+      # passed to the {#<<} method after initialization.
+      #
+      # @param [String,Hash] file_or_hash optional String or Hash argument to initialize the data.
+      def initialize(file_or_hash = nil, opt = {})
+        super _file_to_hash(file_or_hash), opt
+      end
+
+      # Load configuration parameters from a YAML file or Hash.
+      #
+      # The YAML file can contain ERB syntax values that will be evaluated at loading time. Instead of a YAML file,
+      # a Hash can be passed.
+      #
+      # Note that the method also yields the hash or absolute path to a given block. This is for data management of
+      # derived classes such as ::Libis::Tools::Config.
+      #
+      # @param [String,Hash] file_or_hash optional String or Hash argument to initialize the data.
+      def <<(file_or_hash, &block)
+        self.merge!(_file_to_hash(file_or_hash, &block))
+      end
+
+      # Save configuration parameters in a YAML file.
+      #
+      # @param [String] file path of the YAML file to save the configuration to.
+      def >>(file)
+        File.open(file, 'w') { |f| f.write to_hash.to_yaml }
+      end
+
+      protected
+
+      def _file_to_hash(file_or_hash)
+        return {} if file_or_hash.nil? || (file_or_hash.respond_to?(:empty?) && file_or_hash.empty?)
+        hash = case file_or_hash
+                 when Hash
+                   yield file_or_hash if block_given?
+                   file_or_hash
+                 when String
+                   return {} unless File.exist?(file_or_hash)
+                   yield File.absolute_path(file_or_hash) if block_given?
+                   # noinspection RubyResolve
+                   begin
+                   YAML.load(ERB.new(open(file_or_hash).read).result)
+                   rescue Exception => e
+                     raise RuntimeError, "Error loading YAML '#{file_or_hash}': #{e.message}"
+                   end
+                 else
+                   {}
+               end
+        hash = {} unless hash.is_a? Hash
+        hash
+      end
+
+    end
+  end
+end

data/lib/libis/tools/csv.rb

@@ -0,0 +1,38 @@
+require 'csv'
+
+module Libis
+  module Tools
+    module Csv
+
+      # @param [String] file_name
+      # @param [Hash] options
+      # @return [CSV] Open CSV object
+      def self.open(file_name, options = {})
+        options = {
+            mode: 'rb:UTF-8',
+            required: %w'',
+            optional: %w'',
+            col_sep: ',',
+            quote_char: '"'
+        }.merge options
+        mode = options.delete(:mode)
+        required_headers = options.delete(:required)
+        optional_headers = options.delete(:optional)
+        options[:headers] = true
+        options[:return_headers] = true
+        csv = CSV.open(file_name, mode, options)
+        line = csv.shift
+        found_headers = required_headers & line.headers
+        return csv if found_headers.size == required_headers.size
+        raise RuntimeError, "CSV headers not found: #{required_headers - found_headers}" unless found_headers.empty?
+        csv.close
+        options[:headers] = (required_headers + optional_headers)[0...line.size]
+        raise RuntimeError, 'CSV does not contain enough columns' if required_headers.size > line.size
+        options[:return_headers] = true
+        csv = CSV.open(file_name, mode, options)
+        csv.shift
+        csv
+      end
+    end
+  end
+end

data/lib/libis/tools/deep_struct.rb

@@ -0,0 +1,71 @@
+require 'libis/tools/extend/ostruct'
+require 'recursive-open-struct'
+
+module Libis
+  module Tools
+
+    # A class that derives from OpenStruct through the RecursiveOpenStruct.
+    # By wrapping a Hash recursively, it allows for easy access to the content by method names.
+    # A RecursiveOpenStruct is derived from stdlib's OpenStruct, but can be made recursive.
+    # DeepStruct enforces this behaviour and adds a clear! method.
+    class DeepStruct < RecursiveOpenStruct
+      include Enumerable
+
+      # Create a new DeepStruct from a Hash and configure the behaviour.
+      #
+      # @param [Hash] hash the initial data structure.
+      # @param [Hash] opts optional configuration options:
+      #           * recurse_over_arrays: also wrap the Hashes that are enbedded in Arrays. Default: true.
+      #           * preserver_original_keys: creating a Hash from the wrapper preserves symbols and strings as keys. Default: true.
+      def initialize(hash = {}, opts = {})
+        hash = {} unless hash
+        opts = {} unless opts
+        hash = {default: hash} unless hash.is_a? Hash
+        super(hash, {recurse_over_arrays: true, preserve_original_keys: true}.merge(opts))
+      end
+
+      def merge(hash)
+        return self unless hash.respond_to?(:to_hash)
+        hash.to_hash.inject(self.dup) do |ds, (key, value)|
+          ds[key] = DeepDup.new(
+              recurse_over_arrays: @recurse_over_arrays,
+              preserve_original_keys: @preserve_original_keys
+          ).call(value)
+          ds
+        end
+      end
+
+      def merge!(hash)
+        return self unless hash.respond_to?(:to_hash)
+        hash.to_hash.inject(self) do |ds, (key, value)|
+          ds[key] = DeepDup.new(
+              recurse_over_arrays: @recurse_over_arrays,
+              preserve_original_keys: @preserve_original_keys
+          ).call(value)
+          ds
+        end
+        self
+      end
+
+      def key?(key)
+        self.respond_to?(key)
+      end
+      alias_method :has_key?, :key?
+
+      def keys
+        @table.keys
+      end
+
+      def each(&block)
+        self.each_pair &block
+      end
+
+      # Delete all data fields
+      def clear!
+        @table.keys.each { |key| delete_field(key) }
+        @sub_elements = {}
+      end
+
+    end
+  end
+end