avm 0.6.1 → 0.10.0

data/lib/avm/instances/base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+require 'eac_ruby_utils/simple_cache'
+require 'avm/instances/entries'
+
+module Avm
+  module Instances
+    class Base
+      enable_listable
+      enable_simple_cache
+      require_sub __FILE__, include_modules: true
+      include ::Avm::Instances::Entries
+
+      lists.add_string :access, :local, :ssh
+
+      ID_PATTERN = /\A([a-z0-9]+(?:\-[a-z0-9]+)*)_(.+)\z/.freeze
+
+      class << self
+        def by_id(id)
+          application_id, suffix = parse_id(id)
+          require 'avm/instances/application'
+          new(::Avm::Instances::Application.new(application_id), suffix)
+        end
+
+        private
+
+        def parse_id(id)
+          m = ID_PATTERN.match(id)
+          return [m[1], m[2]] if m
+
+          raise "ID Pattern no matched: \"#{id}\""
+        end
+      end
+
+      common_constructor :application, :suffix do
+        self.suffix = suffix.to_s
+      end
+
+      def id
+        "#{application.id}_#{suffix}"
+      end
+
+      def to_s
+        id
+      end
+
+      def host_env_uncached
+        access = read_entry(:access, list: ::Avm::Instances::Base.lists.access.values)
+        case access
+        when 'local' then ::EacRubyUtils::Envs.local
+        when 'ssh' then ::EacRubyUtils::Envs.ssh(read_entry('ssh.url'))
+        else raise("Unmapped access value: \"#{access}\"")
+        end
+      end
+
+      private
+
+      def source_instance_uncached
+        ::Avm::Instances::Base.by_id(source_instance_id)
+      end
+    end
+  end
+end

data/lib/avm/instances/entries.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/instances/entry'
+
+module Avm
+  module Instances
+    module Entries
+      def entry(suffix, options = {})
+        ::Avm::Instances::Entry.new(self, suffix, options)
+      end
+
+      def path_prefix
+        @path_prefix ||= [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
+
+      def inherited_entry_value(source_entry_suffix, target_entry_suffix, &block)
+        read_entry_optional(source_entry_suffix).if_present do |instance_id|
+          other_entry_value(instance_id, target_entry_suffix).if_present(&block)
+        end
+      end
+
+      def other_entry_value(instance_id, entry_suffix)
+        ::Avm::Instances::Base.by_id(instance_id).read_entry_optional(entry_suffix)
+      end
+    end
+  end
+end

data/lib/avm/instances/entry.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'eac_config/node'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Instances
+    class Entry
+      class << self
+        def auto_value_method_name(suffix)
+          "auto_#{suffix.to_s.gsub('.', '_')}"
+        end
+      end
+
+      common_constructor :parent, :suffix, :options
+
+      def auto_value
+        parent.respond_to?(auto_value_method, true) ? parent.send(auto_value_method) : nil
+      end
+
+      def auto_value_method
+        self.class.auto_value_method_name(suffix)
+      end
+
+      def full_path
+        (parent.path_prefix + suffix_as_array).join('.')
+      end
+
+      def optional_value
+        read(required: false, noinput: true) || auto_value
+      end
+
+      def read(extra_options = {})
+        ::EacConfig::Node.context.current.entry(full_path, options.merge(extra_options)).value
+      end
+
+      def suffix_as_array
+        if suffix.is_a?(::Array)
+          suffix.dup
+        else
+          ::EacConfig::PathsHash.parse_entry_key(suffix.to_s)
+        end
+      end
+
+      def value
+        optional_value || read
+      end
+
+      def write(value)
+        ::EacConfig::Node.context.current.entry(full_path).value = value
+      end
+    end
+  end
+end

data/lib/avm/instances/entry_keys.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Instances
+    module EntryKeys
+      class << self
+        def all
+          all_keys.to_a
+        end
+
+        def keys_consts_set(prefix, suffixes)
+          if suffixes.is_a?(::Hash)
+            keys_consts_set_from_hash(prefix, suffixes)
+          elsif suffixes.is_a?(::Enumerable)
+            keys_consts_set_from_enum(prefix, suffixes)
+          else
+            raise "Unmapped suffixes class: #{suffixes.class}"
+          end
+        end
+
+        def key_const_set(prefix, suffix)
+          key = [prefix, suffix].reject(&:blank?).join('.')
+          const_set(key.gsub('.', '_').upcase, key)
+          all_keys << key
+        end
+
+        private
+
+        def all_keys
+          @all_keys ||= ::Set.new
+        end
+
+        def keys_consts_set_from_enum(prefix, suffixes)
+          suffixes.each { |suffix| key_const_set(prefix, suffix) }
+        end
+
+        def keys_consts_set_from_hash(prefix, suffixes)
+          suffixes.each { |k, v| keys_consts_set(prefix.to_s + (k.blank? ? '' : ".#{k}"), v) }
+        end
+      end
+
+      {
+        '' => %w[fs_path host_id source_instance_id],
+        database: %w[id hostname limit name password port system timeout username extra],
+        docker: %w[registry],
+        mailer: {
+          '' => %w[id from reply_to],
+          smtp: %w[address port domain username password authentication starttls_auto]
+        },
+        ssh: %w[hostname port url username],
+        web: %w[authority hostname path port scheme url userinfo]
+      }.each { |prefix, suffixes| keys_consts_set(prefix, suffixes) }
+    end
+  end
+end

data/lib/avm/instances/runner.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+
+module Avm
+  module Instances
+    class Runner
+      class << self
+        def instance_class
+          ::Avm.const_get(stereotype_name).const_get('Instance')
+        end
+
+        def stereotype_module
+          ::Avm.const_get(stereotype_name)
+        end
+
+        def stereotype_name
+          name.demodulize
+        end
+      end
+
+      description = "Utilities for #{stereotype_name} instances."
+      runner_with :help, :subcommands do
+        desc description
+        pos_arg 'instance-id'
+        subcommands
+      end
+
+      delegate :instance_class, :stereotype_module, :stereotype_name, to: :class
+
+      private
+
+      def instance_uncached
+        self.class.instance_class.by_id(parsed.instance_id)
+      end
+    end
+  end
+end

data/lib/avm/instances.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    require 'avm/instances/application'
+    require 'avm/instances/entries'
+  end
+end

data/lib/avm/registry/base.rb

@@ -12,11 +12,11 @@ module Avm
       def detect(*registered_initialize_args)
         detect_optional(*registered_initialize_args) ||
           raise("No registered module valid for #{registered_initialize_args}" \
-            " (Module suffix: #{module_suffix})")
+            " (Module suffix: #{module_suffix}, Available: #{registered_modules.join(', ')})")
       end
 
       def detect_optional(*registered_initialize_args)
-        registered_modules.lazy.map { |klass| klass.new(*registered_initialize_args) }
+        registered_modules.reverse.lazy.map { |klass| klass.new(*registered_initialize_args) }
                           .find(&:valid?)
       end
 
@@ -39,18 +39,20 @@ module Avm
       private
 
       def registered_modules_uncached
-        (single_registered_modules + provider_registered_modules)
-          .select { |v| valid_registered_module?(v) }.uniq.sort_by { |s| [s.name] }
+        registered_gems.flat_map { |registry| modules_from_registry(registry) }
+                       .select { |v| valid_registered_module?(v) }.uniq
       end
 
-      def single_registered_modules
-        single_instance_registry.registered.map(&:registered_module)
+      def modules_from_registry(registry)
+        if registry.registry.module_suffix == provider_module_suffix
+          registry.registered_module.new.all
+        else
+          [registry.registered_module]
+        end
       end
 
-      def provider_registered_modules
-        provider_registry.registered.map(&:registered_module).flat_map do |provider_class|
-          provider_class.new.all
-        end
+      def registered_gems
+        (single_instance_registry.registered + provider_registry.registered).sort
       end
 
       def single_instance_registry_uncached

data/lib/avm/registry.rb

@@ -7,7 +7,7 @@ module Avm
   module Registry
     require_sub __FILE__
     enable_listable
-    lists.add_symbol :category, :instance_stereotypes, :scms, :source_stereotypes
+    lists.add_symbol :category, :instance_stereotypes, :runners, :scms, :sources
 
     class << self
       enable_simple_cache

data/lib/avm/runners/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+
+module Avm
+  module Runners
+    class Base
+      enable_abstract_methods
+
+      class << self
+        def command_argument
+          stereotype_name.underscore.dasherize
+        end
+
+        def stereotype_name
+          name.split('::')[-3]
+        end
+      end
+
+      delegate :command_argument, :stereotype_name, to: :class
+
+      runner_with :help, :subcommands do
+        subcommands
+      end
+
+      def to_s
+        stereotype_name
+      end
+    end
+  end
+end

data/lib/avm/scms/base.rb

@@ -20,6 +20,11 @@ module Avm
         self.class.name.demodulize
       end
 
+      # @return [Enumerable<Avm::Scms::Base>]
+      def subs
+        raise_abstract_method __method__
+      end
+
       def to_s
         name
       end

data/lib/avm/scms/inflector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Avm
+  module Scms
+    class Inflector
+      class << self
+        def default_instance
+          @default_instance ||= new
+        end
+      end
+
+      ISSUE_POINTER_NAME_PREFIX = 'issue_'
+      POINTER_NAME_TO_ISSUE_PATTERN = /\A#{Regexp.quote(ISSUE_POINTER_NAME_PREFIX)}(\d+)\z/.freeze
+      POINTER_NAME_TO_ISSUE_PARSER = POINTER_NAME_TO_ISSUE_PATTERN.to_parser { |m| m[1] }
+
+      # @return [String, nil]
+      def pointer_name_to_issue_id(pointer_name)
+        POINTER_NAME_TO_ISSUE_PARSER.parse(pointer_name)
+      end
+    end
+  end
+end

data/lib/avm/self/docker_image.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/docker/image'
+
+module Avm
+  module Self
+    class DockerImage < ::Avm::Docker::Image
+      def stereotype_tag
+        nil
+      end
+    end
+  end
+end

data/lib/avm/self/instance/entry_keys.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Avm
+  module Self
+    class Instance < ::Avm::Instances::Base
+      module EntryKeys
+        DATA_DEFAULT_PATH = 'data.default_path'
+        DOCKER_REGISTRY_NAME = 'docker.registry.name'
+      end
+    end
+  end
+end

data/lib/avm/self/instance.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'avm/instances/base'
+require 'avm/self/docker_image'
+require 'avm/self/instance/entry_keys'
+require 'avm/eac_ubuntu_base0/docker_image'
+
+module Avm
+  module Self
+    class Instance < ::Avm::Instances::Base
+      def docker_image_class
+        ::Avm::Self::DockerImage
+      end
+
+      def docker_registry
+        read_entry(::Avm::Self::Instance::EntryKeys::DOCKER_REGISTRY_NAME)
+      end
+
+      def docker_run_arguments
+        ['-e', "LOCAL_USER_ID=#{::Process.uid}"]
+      end
+    end
+  end
+end

data/lib/avm/sources/base/configuration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/yaml'
+require 'shellwords'
+
+module Avm
+  module Sources
+    class Base
+      module Configuration
+        # @return [Array<String>, nil]
+        def read_configuration_as_shell_words(key)
+          configuration[key].if_present do |v|
+            v.is_a?(::Enumerable) ? v.map(&:to_s) : ::Shellwords.split(v.to_s)
+          end
+        end
+
+        private
+
+        # @return [Hash]
+        def configuration_uncached
+          ::Avm::Sources::Configuration::FILENAMES.each do |filename|
+            file_path = path.join(filename)
+            return ::EacRubyUtils::Yaml.load_file(file_path).with_indifferent_access if
+            file_path.exist?
+          end
+          {}
+        end
+
+        # @return [Avm::Sources::Configuration]
+        def old_configuration_uncached
+          ::Avm::Sources::Configuration.find_in_path(path)
+        end
+      end
+    end
+  end
+end

data/lib/avm/sources/base/testing.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    class Base
+      module Testing
+        # @return [Avm::Sources::Tester]
+        def tester
+          tester_class.new(self)
+        end
+
+        # @return [Class<Avm::Sources::Tester>
+        def tester_class
+          Avm::Sources::Tester
+        end
+      end
+    end
+  end
+end

data/lib/avm/sources/base.rb

@@ -7,16 +7,20 @@ require 'eac_ruby_utils/core_ext'
 module Avm
   module Sources
     class Base
-      require_sub __FILE__
+      require_sub __FILE__, include_modules: true
+      compare_by :path
+      enable_abstract_methods
       enable_simple_cache
       enable_listable
       lists.add_symbol :option, :parent
       common_constructor :path, :options, default: [{}] do
-        self.path = path.to_pathname
-        self.options = self.class.lists.option.hash_keys_validate!(options)
+        self.path = path.to_pathname.expand_path
+        self.options = ::Avm::Sources::Base.lists.option.hash_keys_validate!(options)
       end
 
-      delegate :locale, to: :configuration
+      abstract_methods :update, :valid?
+
+      delegate :locale, to: :old_configuration
       delegate :to_s, to: :path
 
       # @return [Avm::Sources::Base]
@@ -33,35 +37,15 @@ module Avm
 
       # @return [Enumerable<Avm::Sources::Base>]
       def subs
-        git_repo.subrepos
-                .map { |subrepo| self.class.new(subrepo.subpath.expand_path(path), parent: self) }
-      end
-
-      def update
-        stereotype.update_source(self)
+        scm.subs.map { |subrepo| self.class.new(subrepo.path, parent: self) }
       end
 
       private
 
-      # @return [Avm::Sources::Configuration]
-      def configuration_uncached
-        ::Avm::Sources::Configuration.find_in_path(path) || ::Avm::Sources::Configuration.new
-      end
-
-      # @return [EacGit::Local]
-      def git_repo_uncached
-        ::EacGit::Local.new(path)
-      end
-
       # @return [Avm::Scms::Base]
       def scm_uncached
         ::Avm::Registry.scms.detect(path)
       end
-
-      # @return [Avm::SourceStereotypes::Base]
-      def stereotype_uncached
-        ::Avm::Registry.source_stereotypes.detect(self)
-      end
     end
   end
 end

data/lib/avm/sources/tester.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    class Tester
+      enable_abstract_methods
+      common_constructor :source
+
+      abstract_methods :result, :logs
+
+      # @return [EacRubyUtils::Fs::Logs]
+      def logs
+        raise_abstract_method __method__
+      end
+
+      # @return [Avm::Sources::Tests::Result]
+      def result
+        raise_abstract_method __method__
+      end
+    end
+  end
+end

data/lib/avm/sources/tests/builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'avm/sources/tests/performer'
+require 'avm/sources/tests/single'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    module Tests
+      class Builder
+        require_sub __FILE__
+        enable_immutable
+
+        immutable_accessor :include_main, :include_subs, type: :boolean
+        immutable_accessor :include_id, type: :array
+        common_constructor :main_source
+
+        def immutable_constructor_args
+          [main_source]
+        end
+
+        # @return [Avm::Sources::Tests::Performer]
+        def performer
+          ::Avm::Sources::Tests::Performer.new(self)
+        end
+
+        def selected_units
+          (select_units_from_subs + select_units_from_main + select_units_from_ids).sort.uniq
+        end
+
+        private
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def available_units
+          @available_units ||= ([main_source] + main_source.subs)
+                               .map { |a_source| create_unit(a_source) }
+        end
+
+        def available_units_from_main
+          create_units([main_source])
+        end
+
+        def available_units_from_subs
+          create_units(main_source.subs)
+        end
+
+        # @return [Avm::Sources::Tests::Single]
+        def create_unit(source)
+          ::Avm::Sources::Tests::Single.new(self, source)
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def create_units(sources)
+          sources.map { |a_source| create_unit(a_source) }
+        end
+
+        # @return [Avm::Sources::Tests::Single]
+        def create_unit_by_id(source_id)
+          r = available_units.find { |unit| unit.id == source_id }
+          return r if r
+
+          raise ::ArgumentError, "Source not found with ID=#{source_id}" \
+            "(Available: #{available_units.map(&:id).join(', ')})"
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def select_units_from_ids
+          include_ids.map { |source_id| create_unit_by_id(source_id) }
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def select_units_from_main
+          include_main? ? available_units_from_main : []
+        end
+
+        # @return [Array<Avm::Sources::Tests::Single>]
+        def select_units_from_subs
+          include_subs? ? available_units_from_subs : []
+        end
+      end
+    end
+  end
+end