avm 0.6.0 → 0.9.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/jobs/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'avm/jobs/variables_source'
+require 'avm/result'
 require 'eac_cli/core_ext'
 
 module Avm

data/lib/avm/registry/base.rb

@@ -12,7 +12,7 @@ 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)

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, :source_stereotypes
 
     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/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/source_stereotypes/base.rb

@@ -1,21 +1,35 @@
 # frozen_string_literal: true
 
+require 'avm/source_stereotypes/tester'
 require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/envs'
 
 module Avm
   module SourceStereotypes
     class Base
-      enable_abstract_methods
-      abstract_methods :valid?
       common_constructor :source
 
       def name
         self.class.name
       end
 
+      # @return [Avm::SourceStereotypes::Tester]
+      def tester
+        tester_class.new(self)
+      end
+
+      # @return [Class<Avm::SourceStereotypes::Tester>
+      def tester_class
+        Avm::SourceStereotypes::Tester
+      end
+
       def to_s
         name
       end
+
+      def valid?
+        true
+      end
     end
   end
 end

data/lib/avm/source_stereotypes/tester.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module SourceStereotypes
+    class Tester
+      TEST_COMMAND_CONFIGURATION_KEY = :test_command
+
+      enable_simple_cache
+      common_constructor :source_stereotype
+      delegate :source, to: :source_stereotype
+
+      # @return [EacRubyUtils::Envs::Command, nil]
+      def test_command
+        source.read_configuration_as_shell_words(TEST_COMMAND_CONFIGURATION_KEY)
+              .if_present do |args|
+          ::EacRubyUtils::Envs.local.command(args).chdir(source.path)
+        end
+      end
+
+      private
+
+      def logs_uncached
+        ::EacRubyUtils::Fs::Logs.new.add(:stdout).add(:stderr)
+      end
+
+      # @return [Avm::Sources::Tests::Result]
+      def result_uncached
+        return ::Avm::Sources::Tests::Result::NONEXISTENT if test_command.blank?
+
+        if execute_command_and_log(test_command)
+          ::Avm::Sources::Tests::Result::SUCESSFUL
+        else
+          ::Avm::Sources::Tests::Result::FAILED
+        end
+      end
+
+      def run_test_command
+        execute_command_and_log(test_command)
+      end
+
+      # @return [true, false]
+      def execute_command_and_log(command)
+        r = command.execute
+        logs[:stdout].write(r[:stdout])
+        logs[:stderr].write(r[:stderr])
+        r[:exit_code].zero?
+      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.rb

@@ -7,17 +7,19 @@ 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_simple_cache
       enable_listable
       lists.add_symbol :option, :parent
       common_constructor :path, :options, default: [{}] do
-        self.path = path.to_pathname
+        self.path = path.to_pathname.expand_path
         self.options = self.class.lists.option.hash_keys_validate!(options)
       end
 
-      delegate :locale, to: :configuration
+      delegate :locale, to: :old_configuration
       delegate :to_s, to: :path
+      delegate :tester, to: :stereotype
 
       # @return [Avm::Sources::Base]
       def parent
@@ -43,11 +45,6 @@ module Avm
 
       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)

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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avm/sources/tests/result'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Sources
+    module Tests
+      class Performer
+        enable_simple_cache
+
+        common_constructor(:owner)
+
+        def non_failed_units
+          units.reject(&:failed?)
+        end
+
+        def failed_units
+          units.select(&:failed?)
+        end
+
+        # @return [Boolean]
+        def successful?
+          failed_units.none?
+        end
+
+        protected
+
+        def units_uncached
+          owner.selected_units
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_cli/enum'
+
+module Avm
+  module Sources
+    module Tests
+      class Result < ::EacCli::Enum
+        enum :failed, :red
+        enum :nonexistent, :white
+        enum :sucessful, :green
+      end
+    end
+  end
+end