climatic 0.2.26

data/lib/climatic/initializer.rb

@@ -0,0 +1,87 @@
+module Climatic
+
+  module Initializer
+
+    include Climatic::Utils::ScriptHelper
+
+    attr_reader :config
+
+    def bootstrap(cmd_line_args: ARGV.dup,
+                  command_manager: Climatic::ConfigLayers::CommandLineLayer.default_command_line_manager)
+      raise Climatic::Error, 'You cannot bootstrap Climatic framework twice !' if climatic_bootstrapped?
+      @climatic_status = :bootstrapping
+      setup_initial_logger
+      Climatic.logger.debug 'Starting Climatic framework setup...'
+      # Get the config first to correctly setup the definitive logger
+      setup_config_manager cmd_line_args, command_manager
+      # Now we can setup the definitive logger
+      setup_logger
+      Climatic.logger.debug 'Climatic framework setup complete.'
+      @climatic_status = :bootstrapped
+    rescue Slop::UnknownOption
+      Climatic.logger.debug 'Climatic initialization failed (wrong command line options) !'
+    end
+
+    def climatic_bootstrapping?
+      @climatic_status == :bootstrapping
+    end
+
+    def climatic_bootstrapped?
+      @climatic_status == :bootstrapped
+    end
+
+    private
+
+    def setup_config_manager(cmd_line_args, command_manager)
+      @config = Climatic::LayersManager.new
+      config.command_line_layer.command_line_manager = command_manager
+      config.command_line_layer.cmd_line_args = cmd_line_args
+    end
+
+    def setup_initial_logger
+      @logger = Climatic::Logger::Accumulator.new
+      UltraCommandLine.logger = @logger
+    end
+
+    def setup_logger
+      if config[:debug]
+        log_device = if config[:'log-file']
+                       if File.exists? config[:'log-file']
+                         if File.writable? config[:'log-file']
+                           if config[:'truncate-log-file']
+                             File.open(config[:'log-file'], 'w') do |log_file|
+                               log_file.puts "Log truncated on #{Time.now}"
+                             end
+                           end
+                           config[:'log-file']
+                         else
+                           STDERR.puts "WARNING: Log file '#{config[:'log-file']}' is not writable. Switching to STDERR..."
+                           config[:'log-file'] = nil
+                           STDERR
+                         end
+                       else
+                         if File.writable? File.dirname(config[:'log-file'])
+                           config[:'log-file']
+                         else
+                           STDERR.puts "WARNING: Cannot write log file in '#{File.dirname config[:'log-file']}'. Switching to STDERR..."
+                           config[:'log-file'] = nil
+                           STDERR
+                         end
+                       end
+                     elsif config[:'debug-on-stderr']
+                       STDERR
+                     else
+                       STDOUT
+                     end
+
+        new_logger = ::Logger.new log_device
+        new_logger.level = config[:'log-level'] || Climatic::Logger::Manager::DEFAULT_LOG_LEVEL
+        self.logger = new_logger
+      else
+        self.logger = user_defined_logger
+      end
+    end
+
+  end
+
+end

data/lib/climatic/layers_manager.rb

@@ -0,0 +1,81 @@
+module Climatic
+  class LayersManager < SuperStack::Manager
+
+    include Climatic::ConfigLayers::ProgramDescriptionHelper
+
+    attr_reader :system_layer, :global_layer, :executable_gem_layer, :user_layer, :env_layer,
+                :command_line_layer, :provided_config_file_layer, :project_layer
+
+    def initialize
+      super
+      self.merge_policy = SuperStack::MergePolicies::FullMergePolicy
+      setup_layers
+    end
+
+
+    def self.default_config_file_base_name
+      File.basename($PROGRAM_NAME).gsub /\.[^\.]+$/, ''
+    end
+
+    def include_project_layer(file_or_directory, project_file_basename=nil, priority = 65)
+      @project_layer = Climatic::ConfigLayers::ProjectLayer.new file_or_directory, project_file_basename
+      project_layer.name = 'Project level'
+      project_layer.priority = priority
+      self << project_layer
+    end
+
+    def include_env_layer(filter = nil, priority = 70)
+      @env_layer = Climatic::ConfigLayers::EnvLayer.new filter
+      env_layer.name = 'Environment variables level'
+      env_layer.priority = priority
+      self << env_layer
+    end
+
+    def include_gem_layer_for(gem_name, priority = 30)
+      gem_layer  = Climatic::ConfigLayers::GemLayer.new
+      gem_layer.gem_name = gem_name
+      raise "No config found in gem #{gem_name}" if gem_layer.file_name.nil?
+      gem_layer.name = "#{gem_name} Gem configuration level"
+      gem_layer.priority = priority
+      self << gem_layer
+    end
+
+    private
+
+    def setup_layers
+      # The command line level.
+      @command_line_layer = setup_layer Climatic::ConfigLayers::CommandLineLayer, 'Command line configuration level', 100
+
+      # The system level
+      @system_layer = setup_layer Climatic::ConfigLayers::SystemLayer, 'System-wide configuration level', 10
+
+      # The executable gem level
+      @executable_gem_layer = setup_layer Climatic::ConfigLayers::ExecutableGemLayer, 'Gem associated to the executable running configuration level', 20
+
+      # The global level
+      @global_layer = setup_layer Climatic::ConfigLayers::GlobalLayer, 'Global configuration level', 40
+
+      # The user level
+      @user_layer = setup_layer Climatic::ConfigLayers::UserLayer, 'User configuration level', 50
+
+      # The specifically provided config file level
+      @provided_config_file_layer = setup_layer Climatic::ConfigLayers::ProvidedConfigFileLayer, 'Specific config file configuration level', 60
+
+      # The layer to write something
+      override_layer = setup_layer SuperStack::Layer, 'Overridden configuration level', 1000
+      self.write_layer = override_layer
+
+      reload_layers
+    end
+
+    def setup_layer(class_type, name, priority)
+      layer = class_type.new
+      layer.name = name
+      layer.priority = priority
+      self << layer
+      layer
+    end
+
+
+  end
+end

data/lib/climatic/logger/accumulator.rb

@@ -0,0 +1,49 @@
+module Climatic
+  module Logger
+
+    class Accumulator
+
+      STACK_OPS = %i(debug info warn error fatal unknown).freeze
+
+      attr_accessor :level
+
+      def initialize
+        @log_lines = [{op: :debug, args: ['Starting special temporary "accumulator" logger...']}]
+      end
+
+      def stack(op, *args)
+        log_lines << {op: op, args: args}
+      end
+
+      def transfer_content_to(other_logger)
+        debug "Transferring accumulated logs to logger '#{other_logger.inspect}'"
+        if other_logger.nil?
+          @log_lines = []
+          return
+        end
+        log_lines.each do |log_line|
+          other_logger.send log_line[:op], *log_line[:args]
+        end
+        @log_lines = []
+      end
+
+      def method_missing(method_name, *args)
+        if STACK_OPS.include? method_name
+          stack method_name, *args
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        STACK_OPS.include?(method_name) || super
+      end
+
+      private
+
+      attr_reader :log_lines
+
+    end
+
+  end
+end

data/lib/climatic/logger/manager.rb

@@ -0,0 +1,50 @@
+require 'logger'
+
+
+module Climatic
+  module Logger
+
+    module Manager
+
+      attr_reader :logger
+
+      def puts_and_logs(*args)
+        logger.puts_and_logs *args
+      end
+
+      def logger=(new_logger)
+
+        new_logger ||= DEVNULL_LOGGER
+
+        unless climatic_bootstrapped? or climatic_bootstrapping?
+          @user_defined_logger = new_logger
+          return
+        end
+
+        if climatic_bootstrapped?
+          new_logger.level = config[:'log-level'].nil? ? Climatic::Logger::Manager::DEFAULT_LOG_LEVEL : config[:'log-level']
+        end
+
+        new_logger.extend Climatic::Logger::Wrapper
+
+        if self.logger.respond_to? :transfer_content_to
+          self.logger.transfer_content_to new_logger
+        end
+
+        UltraCommandLine.logger = new_logger
+        @logger = new_logger
+      end
+
+      protected
+
+      attr_reader :user_defined_logger
+
+      private
+
+      DEFAULT_LOG_LEVEL = ::Logger::Severity::WARN
+      DEVNULL_LOGGER = UltraCommandLine::Utils::BasicLogger::NullLogger.new
+
+    end
+
+  end
+end

data/lib/climatic/logger/wrapper.rb

@@ -0,0 +1,12 @@
+module Climatic
+  module Logger
+
+    module Wrapper
+      def puts_and_logs(*args)
+        puts *args if Climatic.config[:verbose]
+        info(*args)
+      end
+    end
+
+  end
+end

data/lib/climatic/processes/base.rb

@@ -0,0 +1,51 @@
+require 'open3'
+
+module Climatic
+  module Processes
+
+    class Base
+
+      include Climatic::Processes::Command
+      include Climatic::Processes::TimeManagement
+
+      attr_reader :process_state, :exit_status, :last_pid, :mode
+      attr_accessor :show_output, :log_output
+
+      def initialize(command = nil, mode = :synchronous)
+        self.command = command
+        self.process_state = :not_started
+        self.mode = mode
+        self.creation_time = Time.now
+      end
+
+      def mode=(mode)
+        mode_processor = Object.const_get "Climatic::Processes::#{mode.to_s.capitalize}"
+        self.extend mode_processor
+        @mode = mode.to_sym
+      rescue
+        raise "Invalid process mode '#{mode}'"
+      end
+
+      private
+
+      attr_writer :process_state, :exit_status, :last_pid
+
+      def report(message, to_stdout = true)
+        if show_output
+          to_stdout ? puts(message) : STDERR.puts(message)
+        end
+        if log_output
+            log_line = "[subprocess #{last_pid}] - #{message}"
+            if to_stdout
+              Climatic.logger.debug log_line
+            else
+              Climatic.logger.warn log_line
+            end
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/climatic/processes/command.rb

@@ -0,0 +1,15 @@
+module Climatic
+  module Processes
+
+    module Command
+
+      attr_accessor :command
+
+      def valid?
+        File.exists? self.command.split(' ').first
+      end
+
+    end
+
+  end
+end

data/lib/climatic/processes/synchronous.rb

@@ -0,0 +1,51 @@
+module Climatic
+  module Processes
+
+    module Synchronous
+
+      def execute
+        self.exit_status = nil
+        self.last_pid = nil
+        self.process_state = :running
+        self.start_time = Time.now
+        Open3.popen3(command) do |stdin, stdout, stderr, wait_thread|
+          stdin.close
+          self.last_pid = wait_thread.pid
+          begin
+            monitored_streams = [stdout, stderr]
+            loop do
+              begin
+                readables, writables = IO.select(monitored_streams)
+                writables.each(&:close)
+                readables.each do |io|
+                  begin
+                    buffer = ''
+                    buffer << io.read_nonblock(1) while buffer[-1] != "\n"
+                    report buffer, io == stdout
+                  rescue IO::WaitReadable
+                    next
+                  rescue EOFError => e
+                    monitored_streams.delete io
+                    monitored_streams.empty? ? raise(e) : next
+                  end
+                end
+              rescue EOFError
+                report "End of process #{wait_thread.value.pid}"
+                break
+              end
+            end
+          rescue Errno::EAGAIN
+            retry
+          end
+          self.exit_status = wait_thread.value
+          return self.exit_status
+        end
+      ensure
+        self.end_time = Time.now
+        self.process_state = :terminated
+      end
+
+    end
+
+  end
+end

data/lib/climatic/processes/time_management.rb

@@ -0,0 +1,21 @@
+require 'open3'
+
+module Climatic
+  module Processes
+
+    module TimeManagement
+
+      attr_reader :creation_time, :start_time, :end_time
+
+      def duration
+        end_time - start_time
+      end
+
+      private
+
+      attr_writer :creation_time, :start_time, :end_time
+
+    end
+
+  end
+end

data/lib/climatic/proxy.rb

@@ -0,0 +1,27 @@
+module Climatic
+
+  module Proxy
+
+    def config
+      Climatic.config
+    end
+
+    def logger
+      Climatic.logger
+    end
+
+    def command_line_manager
+      config.command_line_layer.command_line_manager
+    end
+
+    def help
+      config.command_line_layer.help
+    end
+
+    def puts_and_logs(*args)
+      Climatic.logger.puts_and_logs *args
+    end
+
+  end
+
+end

data/lib/climatic/script/base.rb

@@ -0,0 +1,65 @@
+module Climatic
+  module Script
+
+    module Base
+
+      include Climatic::Utils::ScriptHelper
+
+      module ClassMethods
+
+        def start
+          script = new
+          script.run
+        end
+
+      end
+
+      def run
+        # logging startup configuration
+        Climatic.config.command_line_layer.cmd_line_args = ARGV.dup
+        Climatic.logger.debug "Config layers ->\n#{Climatic.config.detailed_layers_info}"
+        Climatic.logger.debug "Merged config -> #{Climatic.config[].to_yaml}"
+        # Displaying (and exiting) command line help
+        display_help_and_exit if Climatic.config[:help]
+        check_config
+        Climatic.logger.info 'Application is starting...'
+        do_process
+        Climatic.logger.info 'Application ended normally...'
+      rescue => e
+        display_exit_error e
+        exit_code = e.respond_to?(:exit_code) ? e.exit_code : 1
+        exit exit_code
+      ensure
+        Climatic.logger.info 'Exiting...'
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      private
+
+      def display_help_and_exit
+        puts Climatic.config.command_line_help
+        exit 0
+      end
+
+      def do_process
+        cmd_line_mngr.processor.execute
+      end
+
+      def cmd_line_mngr
+        Climatic.config.command_line_layer.command_line_manager
+      end
+
+      def check_config
+        # Check options validity in terms of dependencies
+        cmd_line_mngr.command.valid? raise_error: true
+        # Delegates to the processor the functional checks of the config
+        cmd_line_mngr.processor.check_params cmd_line_mngr.cmd_line_args_for_command(cmd_line_mngr.command)
+      end
+
+    end
+
+  end
+end

data/lib/climatic/script/simple.rb

@@ -0,0 +1,31 @@
+module Climatic
+
+  module Script
+
+    class Simple
+
+      include Climatic::Script::UnimplementedProcessor
+      include Climatic::Script::Base
+
+      def initialize
+        register_processor
+      end
+
+      def register_processor(commands = cmd_line_mngr.commands, processor = self)
+        commands = [commands] unless commands.is_a? Array
+        commands.each do |command|
+          cmd_line_mngr.register_processor command, processor
+        end
+      end
+
+      private
+
+      def cmd_line_mngr
+        Climatic.config.command_line_layer.command_line_manager
+      end
+
+    end
+
+  end
+end
+

data/lib/climatic/script/unimplemented_processor.rb

@@ -0,0 +1,19 @@
+module Climatic
+
+  module Script
+
+    module UnimplementedProcessor
+
+      def check_params(command_args)
+        Climatic.logger.debug Climatic.config[].inspect
+        true
+      end
+
+      def execute
+        raise Climatic::Error, 'Not yet implemented !'
+      end
+
+    end
+
+  end
+end

data/lib/climatic/script.rb

@@ -0,0 +1,4 @@
+require 'climatic/script/unimplemented_processor'
+require 'climatic/script/base'
+require 'climatic/script/simple'
+

data/lib/climatic/utils/error.rb

@@ -0,0 +1,5 @@
+module Climatic
+
+  class Error < StandardError; end
+
+end

data/lib/climatic/utils/input.rb

@@ -0,0 +1,65 @@
+module Climatic
+  module Utils
+
+    module Input
+
+      DEFAULT_CONFIRMATION_CHOICES = {
+          true => %w(Yes y),
+          false => %w(No n)
+      }
+
+      def get_user_confirmation(choices: DEFAULT_CONFIRMATION_CHOICES,
+                                default_choice: 'No',
+                                prompt: 'Are you sure ?',
+                                strict: false)
+
+        raise Climatic::Error, 'Invalid choices !' unless choices.is_a? Hash
+        values = choices.values.flatten
+        raise Climatic::Error, "Invalid default choice '#{default_choice}' !" unless values.include? default_choice
+        if Climatic.config[:auto]
+          yield if block_given?
+          return true
+        end
+        full_prompt = '%s (%s): ' % [prompt, choices_string(values, default_choice)]
+        STDOUT.print full_prompt
+        STDOUT.flush
+        input = nil
+        until values.include? input
+          input = STDIN.gets.chomp
+          input = default_choice if input.nil? || input.empty?
+          unless strict
+            input = default_choice unless values.include? input
+          end
+        end
+        choices.each_pair do |res, possible_choices|
+          if possible_choices.include? input
+            if res and block_given?
+              yield
+            end
+            return res
+          end
+        end
+        raise 'Something wrong happened !'
+      end
+
+
+      def get_user_input(prompt, default=nil)
+        full_prompt = (default.nil? or default.empty?) ? "#{prompt}: " : "#{prompt} (default: #{default}): "
+        STDOUT.print full_prompt
+        STDOUT.flush
+        STDIN.gets.chomp
+      end
+
+      private
+
+
+      def choices_string(choices, default_choice, highlight= %w([ ]))
+        choices
+            .map { |choice| choice == default_choice ? "#{highlight.first}#{choice}#{highlight.last}" : choice }
+            .join '/'
+      end
+
+    end
+
+  end
+end

data/lib/climatic/utils/safe_exec.rb

@@ -0,0 +1,28 @@
+module Climatic
+  module Utils
+
+    module SafeExec
+
+      def safely_exec_code(*args, message: nil, &block)
+        if self.config[:simulate]
+          Climatic.logger.puts_and_logs "[SIMULATION MODE]: #{message}" unless message.nil?
+        else
+          Climatic.logger.puts_and_logs message
+          block.call *args
+        end
+      end
+
+      def safely_exec_command(command, message: nil, show_output: false, log_output: true)
+        safely_exec_code command, message: message do |cmd|
+          process = Climatic::Processes::Base.new cmd
+          process.show_output = show_output
+          process.log_output = log_output
+          process.execute
+          process
+        end
+      end
+
+    end
+
+  end
+end

data/lib/climatic/utils/script_helper.rb

@@ -0,0 +1,18 @@
+module Climatic
+  module Utils
+
+    module ScriptHelper
+
+      def display_exit_error(e)
+        puts "Program aborted with message: '#{e.message}'."
+        if Climatic.config[:debug]
+          Climatic.logger.fatal "#{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+        else
+          puts '  Use --debug option for more detail (see --help).'
+        end
+      end
+
+    end
+
+  end
+end