eac_tools 0.119.0 → 0.121.0

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/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/
+      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,34 @@
+# frozen_string_literal: true
+
+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/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_source_wrappers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceDiscovery
+        class RootSourceWrappers
+          acts_as_instance_method
+          enable_speaker
+
+          common_constructor :owner
+
+          # @return [Enumerable<Avm::Launcher::Context::InstanceDiscovery::SourceWrapper>]
+          def result
+            owner.root_sources.map do |source|
+              ::Avm::Launcher::Context::InstanceDiscovery::SourceWrapper.new(
+                owner,
+                ::Avm::Launcher::Paths::Logical.new(
+                  owner.context, nil, source.to_path, "/#{source.basename}"
+                ),
+                nil
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceDiscovery
+        class RootSources
+          acts_as_instance_method
+          enable_speaker
+
+          common_constructor :owner
+
+          # @return [Array<Avm::Launcher::Paths::Logical>]
+          def result
+            ::Avm::Registry.applications.available.sort_by { |a| [a.id] }.map do |application|
+              application_source(application)
+            end.compact_blank.uniq.sort
+          end
+
+          protected
+
+          # @param application [Avm::Applications::Base]
+          # @return [Pathname, nil]
+          def application_source(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}\""
+              begin
+                application.user_local_source_path
+              rescue ::Avm::Registry::DetectionError => e
+                warn "Application \"#{application}\"'s detection raised the error #{e}"
+                nil
+              end
+            else
+              warn "Application \"#{application}\"'s local source path is not a directory"
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceDiscovery
+        class SourceWrapper
+          enable_memoized
+          enable_speaker
+
+          common_constructor :owner, :logical_path, :parent_project
+
+          # @return [Avm::Launcher::Instances::Base, nil]
+          def parent_project_for_sub
+            self_project.presence || parent_project
+          end
+
+          # @return [Enumerable<Avm::Launcher::Instances::Base>]
+          def projects
+            self_project.if_present([]) { |v| [v] } +
+              subs.flat_map(&:projects)
+          end
+
+          # @return [Avm::Launcher::Instances::Base, nil]
+          memoize def self_project
+            return nil unless logical_path.project?
+
+            infov logical_path, logical_path.real
+            ::Avm::Launcher::Instances::Base.instanciate(logical_path,
+                                                         parent_project)
+          end
+
+          # @param sub [Avm::Sources::base]
+          # @return [Avm::Launcher::Context::InstanceDiscovery::SourceWrapper]
+          def sub_wrapper(sub)
+            ::Avm::Launcher::Context::InstanceDiscovery::SourceWrapper.new(
+              owner,
+              logical_path.build_child(sub.relative_path),
+              parent_project_for_sub
+            )
+          end
+
+          # @return [Enumerable<Avm::Launcher::Instances::Base>]
+          def subs
+            warped_source.subs.map { |sub| sub_wrapper(sub) }
+          rescue StandardError => e
+            warn("#{logical_path}: #{e}")
+            []
+          end
+
+          # @return [Avm::Sources::Base]
+          memoize def warped_source
+            ::Avm::Registry.sources.detect(logical_path.warped)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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
+          root_source_wrappers.flat_map(&:projects)
+        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

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Avm
+  module Launcher
+    class Context
+      class Settings
+        include ::EacRubyUtils::SimpleCache
+
+        def initialize(file)
+          unless ::File.exist?(file)
+            ::FileUtils.mkdir_p(::File.dirname(file))
+            ::File.write(file, {}.to_yaml)
+          end
+          @data = YAML.load_file(file)
+        end
+
+        def instance_settings(instance)
+          ::Avm::Launcher::Instances::Settings.new(value(['Instances', instance.name]))
+        end
+
+        private
+
+        def excluded_projects_uncached
+          enum_value(%w[Projects Exclude])
+        end
+
+        def excluded_paths_uncached
+          enum_value(%w[Paths Exclude])
+        end
+
+        def enum_value(path)
+          r = value(path)
+          r.is_a?(Enumerable) ? r : []
+        end
+
+        def value(path)
+          node_value(@data, path)
+        end
+
+        def node_value(data, path)
+          return data if path.empty?
+          return nil unless data.is_a?(Hash)
+
+          node_value(data[path.first], path.drop(1))
+        end
+      end
+    end
+  end
+end