eac_tools 0.117.4 → 0.118.0

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

@@ -1,106 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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

@@ -1,48 +0,0 @@
-# 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

@@ -1,47 +0,0 @@
-# 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

@@ -1,70 +0,0 @@
-# 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

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

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Docker
-    class Runner
-      DOCKER_DEFAULT_REGISTRY_METHOD = :docker_default_registry
-      DOCKER_DEFAULT_REGISTRY_NAME = 'local'
-
-      enable_speaker
-      enable_simple_cache
-
-      runner_with :help do
-        desc 'Manipulate Docker images.'
-        bool_opt '-I', '--image-name', 'Output image name.'
-        arg_opt '-n', '--registry-name', 'Docker registry\'s name.'
-        bool_opt '-p', '--push', 'Push the image to Docker registry.'
-        bool_opt '-r', '--run', 'Run or start a container with builded image.'
-        arg_opt '-B', '--build-arg', 'Argument for "docker build".', repeat: true
-        arg_opt '-E', '--entrypoint-arg', 'Argument for entrypoint on "docker run"', repeat: true
-        bool_opt '-c', '--clear', 'Remove container if exist before run.'
-        bool_opt '-S', '--no-snapshot', 'Does not add "-snapshot" to image tag.'
-        bool_opt '-V', '--no-version', 'Does not add version to image tag.'
-      end
-
-      def run
-        setup
-        banner
-        build
-        output_image_name
-        push
-        container_run
-      end
-
-      # @return [EacDocker::Registry, nil]
-      def docker_default_registry
-        ::EacDocker::Registry.new(default_docker_registry_name)
-      end
-
-      private
-
-      def setup
-        instance.docker_image_options = {
-          registry: registry,
-          snapshot: snapshot?,
-          version: version?
-        }
-      end
-
-      def banner
-        infov 'Registry name', registry
-        infov 'Version?', version?
-        infov 'Snapshot?', snapshot?
-        infov 'Image name', docker_image.tag
-        infov 'Build arguments', build_args
-        infov 'Entrypoint arguments', entrypoint_args
-      end
-
-      def build
-        docker_image.build(build_args)
-        success 'Docker image builded'
-      end
-
-      def build_args
-        parsed.build_arg
-      end
-
-      def docker_container
-        instance.docker_container
-      end
-
-      # @return [String]
-      def default_docker_registry_name
-        DOCKER_DEFAULT_REGISTRY_NAME
-      end
-
-      def docker_image
-        instance.docker_image
-      end
-
-      def entrypoint_args
-        parsed.entrypoint_arg
-      end
-
-      def push
-        docker_image.push if parsed.push?
-      end
-
-      def container_run
-        return unless parsed.run?
-
-        docker_container.run(
-          entrypoint_args: entrypoint_args,
-          clear: parsed.clear?
-        )
-      end
-
-      def output_image_name
-        return unless parsed.image_name
-
-        out("#{docker_image.tag.to_s.strip}\n")
-      end
-
-      def registry_uncached
-        registry_from_option || registry_from_instance || registry_from_default ||
-          fatal_error('No registry defined')
-      end
-
-      def registry_from_option
-        parsed.registry_name.if_present { |v| ::EacDocker::Registry.new(v) }
-      end
-
-      def registry_from_instance
-        instance.docker_registry_optional.if_present { |v| ::EacDocker::Registry.new(v) }
-      end
-
-      def registry_from_default
-        if_respond(DOCKER_DEFAULT_REGISTRY_METHOD, nil)
-      end
-
-      def snapshot?
-        !parsed.no_snapshot?
-      end
-
-      def version?
-        !parsed.no_version?
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/entries/auto_values/entry.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Entries
-    module AutoValues
-      class Entry
-        class << self
-          # @param path [EacConfig::EntryPath]
-          # @return String
-          def auto_value_method_name(path)
-            "auto_#{::EacConfig::EntryPath.assert(path).to_string.gsub('.', '_')}"
-          end
-        end
-
-        # @!method initialize(entries_provider, path)
-        #   @param entries_provider
-        #   @param path [EacConfig::EntryPath]
-        common_constructor :entries_provider, :path do
-          self.path = ::EacConfig::EntryPath.assert(path)
-        end
-
-        def auto_value_method
-          self.class.auto_value_method_name(path)
-        end
-
-        def found?
-          entries_provider.respond_to?(auto_value_method, true)
-        end
-
-        def value
-          entries_provider.if_respond(auto_value_method)
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/entries/auto_values/uri_entry.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Entries
-    module AutoValues
-      class UriEntry
-        common_constructor :entries_provider, :suffix
-
-        def found?
-          value.present?
-        end
-
-        def value
-          ::Avm::Entries::UriBuilder.from_all_fields do |field_name|
-            entries_provider.entry([suffix, field_name]).optional_value
-          end.to_uri.to_s
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/entries/base/inherited_entry_value.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Entries
-    module Base
-      class InheritedEntryValue
-        enable_method_class
-        common_constructor :entries_provider, :source_entry_suffix, :target_entry_suffix, :block,
-                           block_arg: true
-
-        def result
-          self_entry_value.if_present do |instance_id|
-            other_entry_value(instance_id).if_present(&block)
-          end
-        end
-
-        # @param provider_id [String]
-        # @return [Avm::Entries::Base]
-        def other_entries_provider(provider_id)
-          other_entries_provider_class.by_id(provider_id)
-        end
-
-        # @return [Class]
-        def other_entries_provider_class
-          [::Avm::Instances::Base, ::Avm::Applications::Base].each do |klass|
-            return klass if entries_provider.is_a?(klass)
-          end
-
-          raise "No provider class found for \"#{entries_provider}\""
-        end
-
-        def other_entry_value(instance_id)
-          other_entries_provider(instance_id).read_entry_optional(target_entry_suffix)
-        end
-
-        def self_entry_value
-          entries_provider.read_entry_optional(source_entry_suffix)
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/entries/base/uri_component_entry_value/default_value.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Entries
-    module Base
-      class UriComponentEntryValue
-        class DefaultValue
-          enable_method_class
-          common_constructor :uri_component_entry_value
-          delegate :component_entry_path, :entries_provider, to: :uri_component_entry_value
-
-          # @return [Symbol]
-          def default_value_method_name
-            component_entry_path.default_method_name
-          end
-
-          def result
-            entries_provider.if_respond(default_value_method_name)
-          end
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/entries/base/uri_component_entry_value/inherited_value.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Entries
-    module Base
-      class UriComponentEntryValue
-        class InheritedValue
-          enable_method_class
-          common_constructor :uri_component_entry_value
-          delegate :entries_provider, :id_entry_path, :component_entry_path,
-                   to: :uri_component_entry_value
-
-          def result
-            entries_provider.inherited_entry_value(
-              id_entry_path.to_string,
-              component_entry_path.to_string,
-              &inherited_value_block
-            )
-          end
-
-          def inherited_value_block
-            return nil unless entries_provider.respond_to?(inherited_value_block_method_name)
-
-            ->(value) { entries_provider.send(inherited_value_block_method_name, value) }
-          end
-
-          # @return [Symbol]
-          def inherited_value_block_method_name
-            component_entry_path.inherited_block_method_name
-          end
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/entries/base/uri_component_entry_value/url_entry_value.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Entries
-    module Base
-      class UriComponentEntryValue
-        class UrlEntryValue
-          enable_method_class
-          common_constructor :uri_component_entry_value
-          delegate :component, :entries_provider, :root_entry_path, to: :uri_component_entry_value
-
-          def result
-            return unless url_entry.context_found?
-
-            ::Avm::Entries::UriBuilder.from_source(url_entry.value.to_uri)
-              .avm_field_get(component)
-          end
-
-          # @return [Avm::Entries::Entry]
-          def url_entry
-            entries_provider.entry((root_entry_path + %w[url]).to_string)
-          end
-        end
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/entries/base/uri_component_entry_value.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Entries
-    module Base
-      class UriComponentEntryValue
-        enable_method_class
-        require_sub __FILE__, require_dependency: true
-
-        enable_listable
-        lists.add_symbol :option
-
-        common_constructor :entries_provider, :component_entry_path, :options, default: [{}] do
-          self.component_entry_path = ::EacConfig::EntryPath.assert(component_entry_path)
-          self.options = self.class.lists.option.hash_keys_validate!(options)
-        end
-
-        # @return [EacConfig::EntryPath]
-        def id_entry_path
-          root_entry_path + %w[id]
-        end
-
-        # @return [String, nil]
-        def result
-          url_entry_value || inherited_value || default_value
-        end
-
-        # @return [EacConfig::EntryPath]
-        def root_entry_path
-          component_entry_path[0..-2]
-        end
-
-        # @return [String]
-        def component
-          component_entry_path.last
-        end
-      end
-    end
-  end
-end