eac_tools 0.101.2 → 0.102.0

data/sub/avm/lib/avm/instances/base/web.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'addressable'
+
+module Avm
+  module Instances
+    class Base
+      module Web
+        common_concern do
+          uri_components_entries_values 'web'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    class Base
+      enable_abstract_methods
+      enable_listable
+      enable_simple_cache
+      include ::Avm::Entries::Base
+      require_sub __FILE__, include_modules: true
+      include ::Avm::With::ExtraSubcommands
+      include ::Avm::With::ApplicationStereotype
+
+      lists.add_string :access, :local, :ssh
+
+      ID_PATTERN = /\A([a-z0-9]+(?:-[a-z0-9]+)*)_(.+)\z/.freeze
+
+      class << self
+        def by_id(id)
+          parsed_id = ::Avm::Instances::Ids.parse!(id)
+
+          new(::Avm::Applications::Base.new(parsed_id.application_id), parsed_id.instance_suffix)
+        end
+      end
+
+      common_constructor :application, :suffix do
+        self.suffix = suffix.to_s
+      end
+
+      # @return [Avm::Instances::Data::Package]
+      def data_package
+        @data_package ||= data_package_create
+      end
+
+      # @return [Avm::Instances::Data::Package]
+      def data_package_create
+        ::Avm::Instances::Data::Package.new(self)
+      end
+
+      # @return [String]
+      def id
+        ::Avm::Instances::Ids.build(application.id, suffix)
+      end
+
+      def to_s
+        id
+      end
+
+      def host_env_uncached
+        case install_scheme
+        when 'file' then ::EacRubyUtils::Envs.local
+        when 'ssh' then ::EacRubyUtils::Envs.ssh(install_url)
+        else raise("Unmapped access value: \"#{install_scheme}\"")
+        end
+      end
+
+      # @return [Boolean]
+      def local?
+        suffix == ::Avm::Applications::Base::LocalInstance::LOCAL_INSTANCE_SUFFIX
+      end
+
+      private
+
+      def source_instance_uncached
+        ::Avm::Instances::Base.by_id(source_instance_id)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/instances/data/files_unit.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    module Data
+      class FilesUnit < ::Avm::Instances::Data::Unit
+        EXTENSION = '.tar.gz'
+
+        enable_listable
+        lists.add_symbol :option, :sudo_user
+
+        common_constructor :instance, :fs_path_subpath, :options, default: [{}],
+                                                                  super_args: -> { [instance] } do
+          self.fs_path_subpath = fs_path_subpath.to_pathname
+          self.options = self.class.lists.option.hash_keys_validate!(options)
+        end
+
+        # @return [Pathname]
+        def files_path
+          fs_path_subpath
+            .expand_path(instance.read_entry(::Avm::Instances::EntryKeys::INSTALL_PATH))
+        end
+
+        def dump_command
+          instance_command('tar', '-czf', '-', '-C', files_path, '.')
+        end
+
+        def load_command
+          instance_command('tar', '-xzf', '-', '-C', files_path)
+        end
+
+        def do_clear
+          instance_command('mkdir', '-p', files_path).execute!
+          instance_command('find', files_path, '-mindepth', 1, '-delete').execute!
+        end
+
+        # @return [Struct(:key, :subpath), nil]
+        def installation_files_data
+          return nil unless fs_path_subpath.relative?
+
+          ::Struct.new(:key, :subpath).new(fs_path_subpath.basename.to_path, fs_path_subpath)
+        end
+
+        # @return [EacRubyUtils::Envs::Command]
+        def instance_command(*args)
+          args = ['sudo', '-Hu', sudo_user] + args if sudo_user.present?
+          instance.host_env.command(*args).chdir('/')
+        end
+
+        # @return [String, nil]
+        def sudo_user
+          options[OPTION_SUDO_USER]
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/instances/data/loading_denied_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    module Data
+      class LoadingDeniedError < ::RuntimeError
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/instances/data/package.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    module Data
+      class Package < ::Avm::Data::Package
+        attr_reader :instance
+
+        def initialize(instance, options = {})
+          @instance = instance
+          super(options)
+        end
+
+        # @return [Pathname]
+        def data_default_dump_path
+          instance.data_default_dump_path.to_pathname
+        end
+
+        def load(...)
+          instance.on_disabled_processes { super }
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/instances/data/unit.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    module Data
+      class Unit < ::Avm::Data::UnitWithCommands
+        common_constructor :instance
+
+        # @return [void]
+        # @raise Avm::Instances::Data::Unit
+        def check_load_permission!
+          return if instance.data_allow_loading
+
+          raise ::Avm::Instances::Data::LoadingDeniedError, "Instance: #{instance}"
+        end
+
+        # @return [Pathname]
+        def data_default_dump_path
+          instance.data_default_dump_path.to_pathname.basename_sub('.*') do |b|
+            "#{b}_#{identifier}#{dump_path_extension}"
+          end
+        end
+
+        # @return [String]
+        def identifier
+          instance.data_package.units.key(self) || raise("No identifier found for #{self}")
+        end
+
+        def load(...)
+          check_load_permission!
+          instance.on_disabled_processes { super }
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/instances/data.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    module Data
+    end
+  end
+end

data/sub/avm/lib/avm/instances/docker_image.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    class DockerImage < ::Avm::Docker::Image
+      attr_accessor :instance
+
+      def stereotype_tag
+        instance.id
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/instances/entry_keys.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    module EntryKeys
+      URI_FIELDS = ::Avm::Entries::UriBuilder::ENTRIES_FIELDS + %w[url]
+
+      class << self
+        def all
+          all_keys.to_a
+        end
+
+        def keys_consts_set(prefix, suffixes)
+          all_keys.merge(::Avm::Entries::KeysConstantsSet.new(self, prefix, suffixes).result)
+        end
+
+        private
+
+        def all_keys
+          @all_keys ||= ::Set.new
+        end
+      end
+
+      {
+        '' => %w[name source_instance_id],
+        admin: URI_FIELDS + %w[api_key],
+        data: %w[allow_loading default_dump_path],
+        database: URI_FIELDS + %w[id limit name system timeout extra],
+        docker: %w[registry],
+        install: URI_FIELDS + %w[id data_path email groupname],
+        mailer: {
+          '' => %w[id from reply_to],
+          smtp: URI_FIELDS + %w[address domain authentication openssl_verify_mode starttls_auto tls]
+        },
+        web: URI_FIELDS
+      }.each { |prefix, suffixes| keys_consts_set(prefix, suffixes) }
+    end
+  end
+end

data/sub/avm/lib/avm/instances/ids.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    module Ids
+      ID_PARTS_SEPARATOR = '_'
+      ID_PATTERN = /\A([a-z0-9]+(?:-[a-z0-9]+)*)_(.+)\z/.freeze
+      ID_PARSER = ID_PATTERN.to_parser do |m|
+        ::Struct.new(:application_id, :instance_suffix).new(m[1], m[2])
+      end
+
+      class << self
+        # @param application_id [String]
+        # @param instance_suffix [String]
+        # @return [String]
+        def build(application_id, instance_suffix)
+          [application_id, instance_suffix].join(ID_PARTS_SEPARATOR)
+        end
+
+        # @param id [String]
+        # @return [String]
+        def parse!(id) # rubocop:disable Rails/Delegate
+          ID_PARSER.parse!(id)
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/instances/process.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    class Process
+      class << self
+        # @return [Symbol]
+        def default_id
+          name.demodulize.underscore.to_sym
+        end
+      end
+
+      acts_as_abstract :available?, :disable, :enable, :enabled?
+      common_constructor :instance, :id, default: [nil] do
+        self.id ||= (id || self.class.default_id).to_sym
+      end
+
+      def on_disabled(&block)
+        previous_enabled = enabled?
+        begin
+          disable if previous_enabled
+          block.call
+        ensure
+          enable if previous_enabled
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+
+module Avm
+  module Instances
+    class Runner < ::Avm::Runners::Base
+      runner_with :help, :subcommands do
+        desc 'Utilities for a instance.'
+        pos_arg 'instance-id'
+        subcommands
+      end
+
+      delegate :class, to: :instance, prefix: true
+      for_context :instance
+
+      def extra_available_subcommands
+        instance.if_present({}, &:extra_available_subcommands)
+      end
+
+      def stereotype_module
+        instance.application.stereotype.namespace_module
+      end
+
+      def stereotype_name
+        stereotype_module.name
+      end
+
+      private
+
+      def instance_uncached
+        parsed.instance_id.if_present { |v| ::Avm::Registry.instances.detect(v) }
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/instances.rb

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

data/sub/avm/lib/avm/launcher/context/instance_collector.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceCollector
+        common_constructor :context
+
+        def add_all
+          instances_set.merge(context.instances)
+          self
+        end
+
+        def add_path(path)
+          instances_set.merge(instances_on_path(path))
+          self
+        end
+
+        def add_pending
+          instances_set.merge(context.pending_instances)
+          self
+        end
+
+        def instances
+          instances_set.sort
+        end
+
+        private
+
+        def instance_match?(instance, instance_name)
+          ::File.fnmatch?(instance_name, instance.name)
+        end
+
+        def instances_on_path(path)
+          context.instances.select { |instance| instance_match?(instance, path) }
+        end
+
+        def instances_set
+          @instances_set ||= ::Set.new
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_discovery/root_instance_paths.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceDiscovery
+        class RootInstancePaths
+          acts_as_instance_method
+          enable_speaker
+
+          common_constructor :owner
+
+          # @return [Array<Avm::Launcher::Paths::Logical>]
+          def result
+            application_user_local_source_paths.map do |path|
+              ::Avm::Launcher::Paths::Logical.new(owner.context, nil, path.to_path,
+                                                  "/#{path.basename}")
+            end
+          end
+
+          private
+
+          # @param application [Avm::Applications::Base]
+          # @return [Pathname, nil]
+          def application_user_local_source_path(application) # rubocop:disable Metrics/MethodLength
+            if application.user_local_source_path.blank?
+              warn "Application \"#{application}\" does not have a user local source set"
+              nil
+            elsif application.user_local_source_path.directory?
+              infov application,
+                    "user local source found in \"#{application.user_local_source_path}"
+              application.user_local_source_path
+            else
+              warn "Application \"#{application}\"'s local source path is not a directory"
+              nil
+            end
+          end
+
+          # @return [Array<Pathname>]
+          def application_user_local_source_paths
+            ::Avm::Registry.applications.available.sort_by { |a| [a.id] }.map do |application|
+              application_user_local_source_path(application)
+            end.compact_blank.uniq.sort
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_discovery.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceDiscovery
+        enable_simple_cache
+
+        # @!method instances
+        #   @return [Array<Avm::Launcher::Instances::Base>]
+
+        # @!method initialize(context)
+        #   @param context [Avm::Launcher::Context]
+        common_constructor :context
+
+        private
+
+        # @return [Array<Avm::Launcher::Instances::Base>]
+        def instances_uncached
+          @progress = ::ProgressBar.create(title: 'Instance discovery', total: 1)
+          root_instance_paths.flat_map { |path| path_instances(path, nil) }
+        ensure
+          @progress&.finish
+        end
+
+        # @param path [Avm::Launcher::Paths::Logical]
+        # @param parent_instance [Avm::Launcher::Instances::Base]
+        # @return [Array<Avm::Launcher::Instances::Base>]
+        def path_instances(path, parent_instance)
+          update_progress_format(path)
+          on_rescued_path_instances(path) do |r|
+            if path.project?
+              parent_instance = ::Avm::Launcher::Instances::Base.instanciate(path, parent_instance)
+              r << path
+            end
+            children = path.children
+            update_progress_count(children)
+            r.concat(children.flat_map { |c| path_instances(c, parent_instance) })
+          end
+        end
+
+        # @param path [Avm::Launcher::Paths::Logical]
+        # @return [Array<Avm::Launcher::Instances::Base>]
+        def on_rescued_path_instances(path)
+          r = []
+          begin
+            yield(r) if path.included?
+          rescue StandardError => e
+            warn("#{path}: #{e}")
+          end
+          r
+        end
+
+        # @param path [Avm::Launcher::Paths::Logical]
+        # @return [void]
+        def update_progress_format(path)
+          @progress.format = "%t (Paths: %c/%C, Current: #{path.logical}) |%B| %a"
+        end
+
+        # @param path [Array<Avm::Launcher::Paths::Logical>]
+        # @return [void]
+        def update_progress_count(children)
+          @progress.total += children.count
+          @progress.increment
+        end
+
+        require_sub __FILE__, require_mode: :kernel
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_manager/cached_instance.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        class CachedInstance
+          enable_speaker
+          enable_simple_cache
+          common_constructor :cached_instances, :data
+
+          private
+
+          def instance_uncached
+            ::Avm::Launcher::Instances::Base.instanciate(path, parent_instance)
+          rescue ::Avm::Launcher::Errors::NonProject
+            warn "Cached instance \"#{data[:logical]}\" not found"
+            nil
+          end
+
+          def parent_instance_uncached
+            data[:parent]
+              .if_present { |v| cached_instances.by_logical_path(v) }
+              .if_present(&:instance)
+          end
+
+          def path_uncached
+            ::Avm::Launcher::Paths::Logical.from_h(cached_instances.context, data)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_manager/cached_instances.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        class CachedInstances
+          enable_simple_cache
+          common_constructor :context, :content
+
+          def instances
+            content.keys.map { |k| by_logical_path(k).instance }.compact_blank
+          end
+
+          def by_logical_path(key)
+            cached_instances[key].if_blank do
+              cached_instances[key] = ::Avm::Launcher::Context::InstanceManager::CachedInstance.new(
+                self, content.fetch(key)
+              )
+            end
+          end
+
+          private
+
+          def cached_instances_uncached
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_manager.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require('yaml')
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        enable_simple_cache
+        common_constructor :context
+
+        def publish_state_set(instance, stereotype_name, check_status)
+          data = cached_instances_file_content_uncached
+          data[instance.logical] ||= {}
+          data[instance.logical][:publish_state] ||= {}
+          data[instance.logical][:publish_state][stereotype_name] = check_status
+          write_cache_file(data)
+        end
+
+        def pending_instances
+          instances.select { |instance| pending_instance?(instance) }
+        end
+
+        private
+
+        def instances_uncached
+          (cached_instances || search_instances).select(&:included?)
+        end
+
+        def search_instances
+          cache_instances(::Avm::Launcher::Context::InstanceDiscovery.new(context).instances)
+        end
+
+        def cached_instances
+          return nil if context.recache
+          return nil unless cached_instances_file_content
+
+          CachedInstances.new(self, cached_instances_file_content).instances
+        end
+
+        def cached_instances_file_content_uncached
+          r = YAML.load_file(cache_file_path)
+          r.is_a?(::Hash) ? r : nil
+        rescue Errno::ENOENT
+          nil
+        end
+
+        def cache_instances(instances)
+          write_cache_file(instances.to_h { |i| [i.logical, i.to_h] })
+          instances
+        end
+
+        def write_cache_file(data)
+          cache_file_path.to_pathname.parent.mkpath
+          ::File.write(cache_file_path, data.to_yaml)
+        end
+
+        def cache_file_path
+          ::File.join(context.cache_root, 'instances.yml')
+        end
+
+        def pending_instance?(instance)
+          data = cached_instances_file_content
+          return false unless data[instance.logical]
+          return false unless data[instance.logical][:publish_state].is_a?(Hash)
+
+          data[instance.logical][:publish_state].any? do |_k, v|
+            ::Avm::Launcher::Publish::CheckResult.pending_status?(v)
+          end
+        end
+      end
+    end
+  end
+end