eac_tools 0.86.13 → 0.87.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'eac_docker/executables'
+require 'eac_ruby_utils/core_ext'
+
+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,76 @@
+# frozen_string_literal: true
+
+require 'avm/version'
+require 'avm/entries/jobs/with_variables_source'
+require 'eac_ruby_utils/core_ext'
+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,121 @@
+# frozen_string_literal: true
+
+require 'eac_docker/registry'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Docker
+    class Runner
+      DOCKER_DEFAULT_REGISTRY_METHOD = :docker_default_registry
+
+      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
+
+      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
+
+      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,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Docker
+    require_sub __FILE__
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_config/node'
+require 'eac_ruby_utils/core_ext'
+
+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,24 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'eac_ruby_utils/core_ext'
+
+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,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Entries
+    module AutoValues
+      require_sub __FILE__
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+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,28 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+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,39 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+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,31 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+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,44 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+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,42 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+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,63 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'avm/patches/eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+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,19 @@
+# frozen_string_literal: true
+
+require 'avm/entries/base/uri_components_entries_values/generic_component'
+require 'eac_ruby_utils/core_ext'
+
+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,28 @@
+# frozen_string_literal: true
+
+require 'avm/entries/base/uri_components_entries_values/generic_component'
+require 'eac_ruby_utils/core_ext'
+
+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)
+            require 'avm/entries/auto_values/uri_entry'
+            ::Avm::Entries::AutoValues::UriEntry.new(entries_provider, 'install').value
+          end
+        end
+      end
+    end
+  end
+end