eac_tools 0.85.1 → 0.86.1

data/sub/avm/lib/avm/file_formats.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module FileFormats
+    require_sub __FILE__
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'avm/self/instance'
+
+module Avm
+  module Instances
+    class Base
+      module AutoValues
+        module Data
+          def auto_data_default_dump_path
+            ::Avm::Self::Instance
+              .default
+              .read_entry_optional(::Avm::Self::Instance::EntryKeys::DATA_DEFAULT_PATH)
+              .if_present do |v|
+              ::File.join(
+                v,
+                "#{id}#{data_package.data_file_extension}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'avm/instances/entry_keys'
+
+module Avm
+  module Instances
+    class Base
+      module AutoValues
+        module Database
+          LOCAL_ADDRESS = '127.0.0.1'
+          LOCAL_ADDRESSES = [LOCAL_ADDRESS, '::1', 'localhost'].freeze
+          DEFAULT_EXTRA = ''
+          DEFAULT_HOSTNAME = LOCAL_ADDRESS
+          DEFAULT_LIMIT = 5
+          DEFAULT_PORTS = {
+            'postgresql' => 5432,
+            'mysql' => 3306,
+            'oracle' => 1521,
+            'sqlserver' => 1433
+          }.freeze
+          DEFAULT_SYSTEM = 'postgresql'
+          DEFAULT_TIMEOUT = 5000
+
+          %w[extra hostname limit system timeout].each do |attr|
+            define_method "auto_database_#{attr}" do
+              database_auto_common(attr) || self.class.const_get("default_#{attr}".upcase)
+            end
+          end
+
+          %w[username password].each do |attr|
+            define_method "auto_database_#{attr}" do
+              database_auto_common(attr) || id
+            end
+          end
+
+          def auto_database_name
+            inherited_entry_value(::Avm::Instances::EntryKeys::DATABASE_ID,
+                                  ::Avm::Instances::EntryKeys::DATABASE_NAME) || id
+          end
+
+          def auto_database_port
+            database_auto_common('port') || database_port_by_system
+          end
+
+          private
+
+          def database_auto_common(suffix)
+            database_key = ::Avm::Instances::EntryKeys.const_get("database_#{suffix}".upcase)
+            inherited_entry_value(::Avm::Instances::EntryKeys::DATABASE_ID, database_key) ||
+              inherited_entry_value(::Avm::Instances::EntryKeys::INSTALL_ID, database_key)
+          end
+
+          def database_port_by_system
+            read_entry_optional(::Avm::Instances::EntryKeys::DATABASE_SYSTEM).if_present do |v|
+              DEFAULT_PORTS.fetch(v)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avm/entries/auto_values/entry'
+require 'avm/entries/entry'
+require 'avm/instances/entry_keys'
+
+module Avm
+  module Instances
+    class Base
+      module AutoValues
+        module Mailer
+          ::Avm::Instances::EntryKeys.all.select { |c| c.to_s.start_with?('mailer.') }
+            .reject { |c| c == ::Avm::Instances::EntryKeys::MAILER_ID }
+            .each do |mailer_key|
+            define_method ::Avm::Entries::AutoValues::Entry.auto_value_method_name(mailer_key) do
+              mailer_auto_common(mailer_key)
+            end
+          end
+
+          def auto_mailer_id
+            inherited_entry_value(::Avm::Instances::EntryKeys::INSTALL_ID,
+                                  ::Avm::Instances::EntryKeys::MAILER_ID) ||
+              read_entry_optional(::Avm::Instances::EntryKeys::INSTALL_ID)
+          end
+
+          private
+
+          def mailer_auto_common(mailer_key)
+            inherited_entry_value(::Avm::Instances::EntryKeys::MAILER_ID, mailer_key)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Avm
+  module Instances
+    class Base
+      module AutoValues
+        module Source
+          def auto_source_instance_id
+            "#{application.id}_dev"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Instances
+    class Base
+      module AutoValues
+        require_sub __FILE__, include_modules: true
+        common_concern
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'eac_docker/executables'
+require 'eac_ruby_utils/core_ext'
+require 'avm/docker/container'
+
+module Avm
+  module Instances
+    class Base
+      module Dockerizable
+        enable_simple_cache
+        attr_reader :docker_image_options
+
+        def docker_image_options=(options)
+          @docker_image_options = ::ActiveSupport::HashWithIndifferentAccess.new(options)
+          reset_cache
+        end
+
+        def docker_container_exist?
+          ::EacDocker::Executables.docker.command.append(
+            ['ps', '-qaf', "name=#{docker_container_name}"]
+          ).execute!.present?
+        end
+
+        def docker_container_name
+          id
+        end
+
+        private
+
+        def docker_container_uncached
+          ::Avm::Docker::Container.new(self)
+        end
+
+        def docker_image_uncached
+          r = docker_image_class.new(docker_image_options.fetch(:registry))
+          r.instance = self if r.respond_to?(:instance)
+          r.version = docker_image_options[:version] if docker_image_options.key?(:version)
+          r.snapshot = docker_image_options[:snapshot] if docker_image_options.key?(:snapshot)
+          r
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avm/instances/entry_keys'
+
+module Avm
+  module Instances
+    class Base
+      module EntryKeys
+        # @return [Enumerable<String>]
+        def entry_keys
+          ::Avm::Instances::EntryKeys.all
+        end
+
+        ::Avm::Instances::EntryKeys.all.each do |key|
+          method_name = key.to_s.variableize
+          define_method method_name do
+            read_entry(key)
+          end
+
+          define_method "#{method_name}_optional" do
+            read_entry_optional(key)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'avm/instances/entry_keys'
+
+module Avm
+  module Instances
+    class Base
+      module Install
+        common_concern do
+          uri_components_entries_values 'install', %w[data_path email groupname]
+        end
+
+        def install_data_path_inherited_value_proc(value)
+          "#{value}/#{id}"
+        end
+
+        def install_groupname_default_value
+          read_entry_optional(::Avm::Instances::EntryKeys::INSTALL_USERNAME)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Instances
+    class Base
+      module Processes
+        # @return [Array<Avm::Instances::Process>]
+        def available_processes
+          processes.select(&:available?)
+        end
+
+        def on_disabled_processes(&block)
+          available_processes.inject(block) do |a, e|
+            -> { e.on_disabled(&a) }
+          end.call
+        end
+
+        # @return [Array<Avm::Instances::Process>]
+        def processes
+          []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner/context'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Instances
+    class Base
+      class SubcommandParent
+        include ::EacCli::Runner
+        enable_simple_cache
+        common_constructor :instance do
+          self.runner_context = ::EacCli::Runner::Context.new(self, argv: runner_argv)
+        end
+        for_context :instance
+
+        private
+
+        def runner_argv
+          [instance.class.name.split('::')[-2].dasherize, instance.id]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'avm/instances/entry_keys'
+
+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,71 @@
+# frozen_string_literal: true
+
+require 'avm/instances/ids'
+require 'avm/with/application_stereotype'
+require 'avm/with/extra_subcommands'
+require 'eac_ruby_utils/require_sub'
+require 'eac_ruby_utils/simple_cache'
+require 'avm/entries/base'
+
+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)
+          require 'avm/applications/base'
+          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
+
+      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,59 @@
+# frozen_string_literal: true
+
+require 'avm/instances/data/unit'
+
+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/package.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avm/data/package'
+
+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(*args, &block)
+          instance.on_disabled_processes { super(*args, &block) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'avm/data/unit_with_commands'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Instances
+    module Data
+      class Unit < ::Avm::Data::UnitWithCommands
+        common_constructor :instance
+
+        # @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(*args, &block)
+          instance.on_disabled_processes { super(*args, &block) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Instances
+    module Data
+      require_sub __FILE__
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'avm/docker/image'
+
+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,43 @@
+# frozen_string_literal: true
+
+require 'avm/entries/keys_constants_set'
+require 'avm/entries/uri_builder'
+require 'eac_ruby_utils/core_ext'
+
+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[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,30 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+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)
+          ID_PARSER.parse!(id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+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