eac_tools 0.103.1 → 0.104.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'eac_docker/images/templatized'
+require 'eac_docker/registry'
+
+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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'eac_docker/registry'
+
+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/docker.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Avm
+  module Docker
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_config/node'
+
+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

@@ -0,0 +1,21 @@
+# 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/auto_values.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module AutoValues
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+
+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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+
+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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+
+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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+
+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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+
+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

data/sub/avm/lib/avm/entries/base/uri_components_entries_values/component_factory.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Base
+      class UriComponentsEntriesValues
+        class ComponentFactory
+          enable_method_class
+          common_constructor :owner, :component
+
+          def result
+            component_class.new(owner, component)
+          end
+
+          def component_class
+            specific_class || generic_class
+          end
+
+          def generic_class
+            parent_class.const_get('GenericComponent')
+          end
+
+          def parent_class
+            ::Avm::Entries::Base::UriComponentsEntriesValues
+          end
+
+          def specific_class
+            return nil unless parent_class.const_defined?(specific_class_basename)
+
+            parent_class.const_get(specific_class_basename)
+          end
+
+          def specific_class_basename
+            [component, 'component'].join('_').camelize
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/base/uri_components_entries_values/generic_component.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Base
+      class UriComponentsEntriesValues
+        class GenericComponent
+          common_constructor :owner, :component
+          delegate :entries_provider_class, :prefix, to: :owner
+          delegate :auto_method_name, :get_method_name, :get_optional_method_name,
+                   to: :entry_key_path
+
+          def define_auto_method
+            outer_self = self
+            entries_provider_class.define_method(auto_method_name) do
+              uri_component_entry_value(outer_self.entry_key_path.to_string)
+            end
+          end
+
+          def define_get_method
+            outer_self = self
+            entries_provider_class.define_method(get_method_name) do
+              read_entry(outer_self.entry_key_path.to_string)
+            end
+          end
+
+          def define_get_optional_method
+            outer_self = self
+            entries_provider_class.define_method(get_optional_method_name) do
+              read_entry_optional(outer_self.entry_key_path.to_string)
+            end
+          end
+
+          def define_inherited_value_proc_method(&block)
+            entries_provider_class.define_method(inherited_value_proc_name, &block)
+          end
+
+          def entry_key_path
+            ::EacConfig::EntryPath.assert([prefix, component])
+          end
+
+          def id_component
+            @id_component ||= owner.component_factory('id')
+          end
+
+          def inherited_value_proc_name
+            entry_key_path.inherited_block_method_name
+          end
+
+          def setup
+            define_auto_method
+            define_get_method
+            define_get_optional_method
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/base/uri_components_entries_values/path_component.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Base
+      class UriComponentsEntriesValues
+        class PathComponent < ::Avm::Entries::Base::UriComponentsEntriesValues::GenericComponent
+          def setup
+            super
+            define_inherited_value_proc_method { |value| "#{value}/#{id}" }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/entries/base/uri_components_entries_values/url_component.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Base
+      class UriComponentsEntriesValues
+        class UrlComponent < ::Avm::Entries::Base::UriComponentsEntriesValues::GenericComponent
+          def define_auto_method
+            outer_self = self
+            entries_provider_class.define_method(auto_method_name) do
+              inherited_entry_value(outer_self.id_component.entry_key_path.to_string,
+                                    outer_self.entry_key_path.to_string) ||
+                outer_self.auto_install_url_by_parts(self)
+            end
+          end
+
+          def auto_install_url_by_parts(entries_provider)
+            ::Avm::Entries::AutoValues::UriEntry.new(entries_provider, 'install').value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Avm
+  module Entries
+    module Base
+      class UriComponentsEntriesValues
+        common_constructor :entries_provider_class, :prefix, :extra_fields
+
+        ENTRIES_FIELDS = ::Avm::Entries::UriBuilder::ENTRIES_FIELDS + %w[url]
+
+        def fields
+          ENTRIES_FIELDS + extra_fields
+        end
+
+        def result
+          fields.map { |field| component_factory(field).setup }
+        end
+
+        require_sub __FILE__, require_mode: :kernel
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+
+module Avm
+  module Entries
+    module Base
+      require_sub __FILE__, require_mode: :kernel
+      common_concern
+
+      module ClassMethods
+        def uri_components_entries_values(prefix, extra_fields = [])
+          ::Avm::Entries::Base::UriComponentsEntriesValues.new(self, prefix, extra_fields).result
+        end
+      end
+
+      def entries_provider_id
+        id
+      end
+
+      # @raise
+      # @return [void]
+      def entries_provider_id!
+        return entries_provider_id unless
+        entries_provider_id.include?(::EacConfig::EntryPath::PART_SEPARATOR)
+
+        raise ".entries_provider_id \"#{entries_provider_id}\" cannot have " \
+              "\"#{::EacConfig::EntryPath::PART_SEPARATOR}\" (EacConfig::EntryPath::PART_SEPARATOR)"
+      end
+
+      def entry(suffix, options = {})
+        ::Avm::Entries::Entry.new(self, suffix, options)
+      end
+
+      def path_prefix
+        @path_prefix ||= [entries_provider_id!].freeze
+      end
+
+      def read_entry(entry_suffix, options = {})
+        entry(entry_suffix, options).value
+      end
+
+      def read_entry_optional(entry_suffix, options = {})
+        entry(entry_suffix, options).optional_value
+      end
+
+      def full_entry_path(entry_suffix)
+        unless entry_suffix.is_a?(::Array)
+          entry_suffix = ::EacConfig::PathsHash.parse_entry_key(entry_suffix.to_s)
+        end
+        (path_prefix + entry_suffix).join('.')
+      end
+    end
+  end
+end