eac_tools 0.97.1 → 0.98.0

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'eac_fs/file_info'
+
+module Avm
+  module FileFormats
+    class Utf8Assert
+      UTF8_CHARSET = 'utf-8'
+      UTF8_CHARSETS = [UTF8_CHARSET, 'us-ascii'].freeze
+
+      class << self
+        def assert_files(files)
+          asserters = files.map { |file| new(file) }
+          begin
+            asserters.each(&:assert)
+            yield
+          ensure
+            asserters.each(&:revert)
+          end
+        end
+      end
+
+      enable_simple_cache
+      common_constructor :path
+
+      def assert
+        return if original_utf8?
+
+        convert_self(original_charset, UTF8_CHARSET)
+      end
+
+      def revert
+        return if original_utf8?
+
+        convert_self(UTF8_CHARSET, original_charset)
+      end
+
+      private
+
+      def original_info_uncached
+        ::EacFs::FileInfo.new(path)
+      end
+
+      def original_charset_uncached
+        return original_info.content_type.charset if original_info.content_type.charset.present?
+
+        raise 'No charset found'
+      rescue StandardError => e
+        raise "Unable to determine the charset of #{path} (#{e.message})"
+      end
+
+      def original_utf8?
+        UTF8_CHARSETS.include?(original_charset)
+      end
+
+      def convert_file(from_path, from_charset, to_path, to_charset)
+        File.open(from_path, "r:#{from_charset}") do |input|
+          File.open(to_path, "w:#{to_charset}") do |output|
+            output.write(input.read)
+          end
+        end
+      end
+
+      def convert_self(from_charset, to_charset)
+        temp = ::Tempfile.new
+        temp.close
+        convert_file(path, from_charset, temp.path, to_charset)
+        ::FileUtils.mv(temp.path, path)
+      end
+    end
+  end
+end

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,30 @@
+# 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
+
+          # @return [Boolean]
+          def auto_data_allow_loading
+            local? || !production?
+          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,18 @@
+# frozen_string_literal: true
+
+require 'avm/applications/base/local_instance'
+
+module Avm
+  module Instances
+    class Base
+      module AutoValues
+        module Source
+          def auto_source_instance_id
+            [application.id, ::Avm::Applications::Base::LocalInstance::LOCAL_INSTANCE_SUFFIX]
+              .join('_')
+          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,31 @@
+# frozen_string_literal: true
+
+require 'avm/entries/uri_builder'
+require 'avm/instances/entry_keys'
+
+module Avm
+  module Instances
+    class Base
+      module Install
+        INSTALL_SCHEME_DEFAULT_VALUE = 'file'
+
+        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
+
+        # @return [String]
+        def install_scheme_default_value
+          INSTALL_SCHEME_DEFAULT_VALUE
+        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/production.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'avm/instances/entry_keys'
+
+module Avm
+  module Instances
+    class Base
+      module Production
+        DEFAULT_PRODUCTION = true
+        PRODUCTION_KEY = 'production'
+
+        # @return [Boolean]
+        def default_production?
+          DEFAULT_PRODUCTION
+        end
+
+        # @return [Boolean]
+        def production?
+          if production_entry.found?
+            production_entry.value.to_bool
+          else
+            default_production?
+          end
+        end
+
+        # @return [Avm::Entries::Entry]
+        def production_entry
+          entry(PRODUCTION_KEY)
+        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,77 @@
+# frozen_string_literal: true
+
+require 'avm/instances/ids'
+require 'avm/applications/base/local_instance'
+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
+
+      # @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,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/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,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(...)
+          instance.on_disabled_processes { super }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'avm/data/unit_with_commands'
+require 'avm/instances/data/loading_denied_error'
+require 'eac_ruby_utils/core_ext'
+
+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,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Instances
+    module Data
+      require_sub __FILE__
+    end
+  end
+end