eac_tools 0.117.2 → 0.117.4

data/sub/avm/lib/avm/data/loader.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Avm
+  module Data
+    class Loader < ::Avm::Data::Performer
+      immutable_accessor :source_path
+
+      # @return [String, nil]
+      def cannot_perform_reason
+        return 'Source path not set' if source_path.blank?
+        return "\"#{source_path}\" is not a file" unless source_path.file?
+
+        nil
+      end
+
+      protected
+
+      def internal_perform
+        data_owner.load(source_path, *include_excludes_arguments)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package/base_performer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Avm
+  module Data
+    class Package
+      class BasePerformer
+        acts_as_abstract :result
+        enable_speaker
+        enable_listable
+        lists.add_symbol :option, :excludes, :includes
+        common_constructor :package, :options, default: [{}] do
+          self.options = ::Avm::Data::Package::BasePerformer.lists.option
+                           .hash_keys_validate!(options)
+        end
+
+        # @return [Set<Symbol>]
+        def excludes
+          ::Set.new((options[OPTION_EXCLUDES] || []).map(&:to_sym))
+        end
+
+        # @return [Set<Symbol>]
+        def includes
+          ::Set.new((options[OPTION_INCLUDES] || []).map(&:to_sym))
+        end
+
+        # @return [Hash<Symbol, Avm::Data::Unit]
+        def selected_units
+          r = package.units
+          r = r.slice(*includes.to_a) if includes.any?
+          r = r.except(*excludes.to_a) if excludes.any?
+          r
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package/build_directory.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Avm
+  module Data
+    class Package
+      module BuildDirectory
+        private
+
+        attr_writer :build_directory
+
+        # @return [EacRubyUtils::Fs::Temp::Directory]
+        def build_directory
+          @build_directory || raise('@build_directory is blank')
+        end
+
+        def on_build_directory
+          ::EacRubyUtils::Fs::Temp.on_directory do |directory|
+            self.build_directory = directory
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package/clear.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Avm
+  module Data
+    class Package
+      class Clear < ::Avm::Data::Package::BasePerformer
+        enable_method_class
+
+        # @return [void]
+        def result
+          selected_units.each do |identifier, unit|
+            infov 'Clearing unit', identifier
+            unit.clear
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package/dump.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'minitar'
+
+module Avm
+  module Data
+    class Package
+      class Dump < ::Avm::Data::Package::BasePerformer
+        enable_method_class
+        include ::Avm::Data::Package::BuildDirectory
+
+        attr_reader :target_path
+
+        def initialize(package, target_path, options = {})
+          super(package, options)
+          @target_path = target_path.to_pathname
+        end
+
+        # @return [void]
+        def result
+          on_build_directory do
+            dump_units_to_build_directory
+            create_package_file
+          end
+        end
+
+        protected
+
+        def dump_units_to_build_directory
+          package.dump_units_to_directory(build_directory, selected_units)
+        end
+
+        def create_package_file
+          infom "Creating package \"#{target_path}\" from \"#{build_directory}\"..."
+          ::Dir.chdir(build_directory.to_path) do
+            ::Minitar.pack('.', ::File.open(target_path, 'wb'))
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package/load.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'minitar'
+
+module Avm
+  module Data
+    class Package
+      class Load < ::Avm::Data::Package::BasePerformer
+        enable_method_class
+        enable_speaker
+        include ::Avm::Data::Package::BuildDirectory
+
+        attr_reader :source_path
+
+        def initialize(package, source_path, options = {})
+          super(package, options)
+          @source_path = source_path.to_pathname
+        end
+
+        def result
+          on_build_directory do
+            extract_packages_to_build_directory
+            package.load_units_from_directory(build_directory, selected_units)
+          end
+        end
+
+        def extract_packages_to_build_directory
+          ::Minitar.unpack(source_path.to_path, build_directory.to_path)
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Avm
+  module Data
+    class Package
+      require_sub __FILE__, require_mode: :kernel
+      include ::Avm::Data::Callbacks
+
+      DATA_FILE_EXTENSION = '.tar'
+
+      def initialize(options)
+        options = options.to_options_consumer
+        units = options.consume(:units)
+        options.validate
+        units.if_present do |v|
+          v.each { |identifier, unit| add_unit(identifier, unit) }
+        end
+      end
+
+      # @return [Avm::Data::Package] Return +self+.
+      def add_unit(identifier, unit)
+        units[identifier.to_sym] = unit
+
+        self
+      end
+
+      # @return [String]
+      def data_file_extension
+        DATA_FILE_EXTENSION
+      end
+
+      def dump_units_to_directory(directory, selected_units = nil)
+        run_callbacks :dump do
+          (selected_units || units).each do |identifier, unit|
+            unit.dump_to_directory(directory, identifier)
+          end
+        end
+      end
+
+      def load_units_from_directory(directory, selected_units = nil)
+        run_callbacks :load do
+          (selected_units || units).each do |identifier, unit|
+            unit.load_from_directory(directory, identifier)
+          end
+        end
+      end
+
+      # @param id [Symbol]
+      # @return [Avm::Data::UnitWithCommands]
+      def unit(identifier)
+        units[identifier.to_sym] || raise("No unit found with identifier \"#{identifier}\"")
+      end
+
+      def units
+        @units ||= {}
+      end
+
+      # @return [Enumerable<String>]
+      def units_ids
+        units.keys
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/performer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Avm
+  module Data
+    class Performer
+      acts_as_abstract(:cannot_perform_reason, :internal_perform)
+      acts_as_immutable
+      common_constructor :data_owner
+      immutable_accessor :exclude, :include, type: :set
+
+      # @return [Enumerable]
+      def immutable_constructor_args
+        [data_owner]
+      end
+
+      # @return [self]
+      def perform
+        raise "Cannot run: #{cannot_perform_reason}" unless performable?
+
+        internal_perform
+
+        self
+      end
+
+      # @return [Boolean]
+      def performable?
+        cannot_perform_reason.blank?
+      end
+
+      protected
+
+      def include_excludes_arguments
+        options = include_excludes_options
+        options.any? ? [options] : []
+      end
+
+      def include_excludes_options
+        r = {}
+        r[:includes] = includes if includes.any?
+        r[:excludes] = excludes if excludes.any?
+        r
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/rotate.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Avm
+  module Data
+    class Rotate
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :options, :source_path
+
+      def initialize(source_path, options = {})
+        @source_path = source_path
+        @options = options
+      end
+
+      def run
+        validate_msg = validate
+        return validate_msg if validate_msg.present?
+
+        ::FileUtils.mv(source_path, target_path)
+        check_space_limit
+        nil
+      end
+
+      def space_limit
+        r = options[:space_limit].try(:to_i)
+        return r if r.present? && r.positive?
+
+        r
+      end
+
+      def space_used
+        rotated_files.inject(0) { |a, e| a + ::File.size(e) }
+      end
+
+      def rotated_files
+        ::Dir["#{dirname}/#{source_basename_without_extension}*#{source_extension}"]
+      end
+
+      def oldest_rotated_file
+        rotated_files.min_by { |file| [::File.mtime(file)] }
+      end
+
+      private
+
+      def check_space_limit
+        return unless space_limit
+
+        while space_used > space_limit
+          file = oldest_rotated_file
+          unless file
+            raise 'oldest_rotated_file returned nil ' \
+                  "(Limit: #{space_limit}, used: #{space_used})"
+          end
+          ::File.delete(file)
+        end
+      end
+
+      def validate
+        return "Source file \"#{source_path}\" does not exist" unless ::File.exist?(source_path)
+        return "File \"#{source_path}\" is already rotated" if source_rotated?
+
+        nil
+      end
+
+      def source_rotated?
+        source_basename_without_extension.match(/[PN]\d{4}\z/)
+      end
+
+      def source_extension_uncached
+        file_extension(::File.basename(source_path))
+      end
+
+      def source_basename_without_extension
+        ::File.basename(source_path, source_extension)
+      end
+
+      def target_path_uncached
+        ::File.join(dirname, target_basename)
+      end
+
+      def dirname
+        ::File.dirname(source_path)
+      end
+
+      def target_basename
+        source_basename_without_extension + target_suffix + source_extension
+      end
+
+      def target_suffix
+        return '_UNKNOWN_MTIME' unless ::File.exist?(source_path)
+
+        t = ::File.mtime(source_path)
+        t.strftime('_%Y-%m-%d_%H-%M-%S_') + t.strftime('%z').gsub(/\A\+/, 'P').gsub(/\A-/, 'N')
+      end
+
+      def file_extension(basename)
+        extension = ::File.extname(basename)
+        return '' if extension.blank?
+
+        file_extension(::File.basename(basename, extension)) + extension
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/unit.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Avm
+  module Data
+    class Unit
+      acts_as_abstract(
+        do_clear: [],
+        do_dump: [:dump_path],
+        do_load: [:dump_path],
+        dump_path_extension: []
+      )
+      enable_speaker
+      include ::Avm::Data::Callbacks
+
+      # @param dump_path [Pathname]
+      # @return [void]
+      def clear
+        run_callbacks(:dump) { do_clear }
+      end
+
+      # @param dump_path [Pathname]
+      # @return [void]
+      def dump(dump_path)
+        run_callbacks :dump do
+          infom "Dumping unit \"#{name}\" to \"#{dump_path}\"..."
+          do_dump(dump_path)
+        end
+      end
+
+      # @param dump_path [Pathname]
+      # @return [void]
+      def load(dump_path)
+        run_callbacks :load do
+          clear
+          infom "Loading unit \"#{name}\" from \"#{dump_path}\"..."
+          do_load(dump_path)
+        end
+      end
+
+      # @return [String]
+      delegate :name, to: :class
+    end
+  end
+end

data/sub/avm/lib/avm/data/unit_with_commands.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Avm
+  module Data
+    class UnitWithCommands < ::Avm::Data::Unit
+      acts_as_abstract
+
+      abstract_method :dump_command
+      abstract_method :load_command
+
+      # @return [String]
+      def dump_path_extension
+        singleton_class.const_get('EXTENSION')
+      rescue NameError
+        ''
+      end
+
+      def load_from_directory(directory, identifier)
+        load(unit_on_directory_path(directory, identifier))
+      end
+
+      def dump_to_directory(directory, identifier)
+        dump(unit_on_directory_path(directory, identifier))
+      end
+
+      # @return [Struct(:key, :subpath), nil]
+      def installation_files_data
+        nil
+      end
+
+      protected
+
+      def do_dump(data_path)
+        dump_command.execute!(output_file: data_path)
+      end
+
+      def do_load(data_path)
+        load_command.execute!(input_file: data_path)
+      end
+
+      private
+
+      def unit_on_directory_path(directory, identifier)
+        ::File.join(directory, "#{identifier}#{dump_path_extension}")
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/docker/container.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Avm
+  module Docker
+    class Container
+      enable_speaker
+      common_constructor :instance
+
+      def remove
+        ::EacDocker::Executables.docker.command.append(
+          ['rm', '--force', instance.docker_container_name]
+        ).system!
+      end
+
+      def run(options = {})
+        infov 'Container name', instance.docker_container_name
+        infov 'Container exist?', instance.docker_container_exist?
+        remove if options[:clear] && instance.docker_container_exist?
+        if instance.docker_container_exist?
+          run_start
+        else
+          run_run(options)
+        end
+      end
+
+      def run_run(options)
+        infom "\"docker run #{instance.docker_container_name}...\""
+        ::EacDocker::Executables.docker.command.append(run_run_arguments(options)).system!
+      end
+
+      def run_start
+        infom "\"docker start #{instance.docker_container_name}...\""
+        ::EacDocker::Executables.docker.command.append(run_start_arguments).system!
+      end
+
+      def run_run_arguments(options)
+        entrypoint_args = options[:entrypoint_args].if_present([])
+        ['run', '-it', '--name', instance.docker_container_name] + instance.docker_run_arguments +
+          [instance.docker_image.tag] + entrypoint_args
+      end
+
+      def run_start_arguments
+        ['start', '-ai', instance.docker_container_name]
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/docker/image.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Avm
+  module Docker
+    class Image < ::EacDocker::Images::Templatized
+      prepend ::Avm::Entries::Jobs::WithVariablesSource
+
+      DEFAULT_REGISTRY_NAME = 'local'
+
+      class << self
+        # @return [EacDocker::Registry]
+        def default_registry
+          ::EacDocker::Registry.new(DEFAULT_REGISTRY_NAME)
+        end
+      end
+
+      attr_reader :registry
+      attr_accessor :snapshot, :version
+
+      def initialize(registry = nil)
+        super()
+        @registry = registry || self.class.default_registry
+        self.snapshot = true
+        self.version = true
+      end
+
+      def build(extra_args = [])
+        nyi "Extra args: #{extra_args}" if extra_args.any?
+
+        provide
+      end
+
+      def generator_version
+        ::Avm::VERSION
+      end
+
+      def push
+        ::EacDocker::Executables.docker.command.append(['push', tag]).system!
+      end
+
+      def run(instance)
+        run_run(instance) if container_exist?(instance)
+      end
+
+      def tag
+        r = tag_name
+        r += ":#{tag_version}" if tag_version.present?
+        r
+      end
+
+      def tag_name
+        return registry.name if registry.name.present?
+
+        raise 'Registry name is blank'
+      end
+
+      def tag_version
+        [tag_version_version, stereotype_tag].compact_blank.join('_')
+      end
+
+      def tag_version_version
+        return nil unless version
+
+        r = generator_version
+        r += '-snapshot' if snapshot
+        r
+      end
+    end
+  end
+end