avm-tools 0.118.0 → 0.120.1

data/sub/avm/lib/avm/data/rotate.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/object/blank'
-require 'eac_ruby_utils/simple_cache'
-
-module Avm
-  module Data
-    class Rotate
-      include ::EacRubyUtils::SimpleCache
-
-      attr_reader :options, :source_path
-
-      def initialize(source_path, options = {})
-        @source_path = source_path
-        @options = options
-      end
-
-      def run
-        validate_msg = validate
-        return validate_msg if validate_msg.present?
-
-        ::FileUtils.mv(source_path, target_path)
-        check_space_limit
-        nil
-      end
-
-      def space_limit
-        r = options[:space_limit].try(:to_i)
-        return r if r.present? && r.positive?
-
-        r
-      end
-
-      def space_used
-        rotated_files.inject(0) { |a, e| a + ::File.size(e) }
-      end
-
-      def rotated_files
-        ::Dir["#{dirname}/#{source_basename_without_extension}*#{source_extension}"]
-      end
-
-      def oldest_rotated_file
-        rotated_files.min_by { |file| [::File.mtime(file)] }
-      end
-
-      private
-
-      def check_space_limit
-        return unless space_limit
-
-        while space_used > space_limit
-          file = oldest_rotated_file
-          unless file
-            raise 'oldest_rotated_file returned nil ' \
-              "(Limit: #{space_limit}, used: #{space_used})"
-          end
-          ::File.delete(file)
-        end
-      end
-
-      def validate
-        return "Source file \"#{source_path}\" does not exist" unless ::File.exist?(source_path)
-        return "File \"#{source_path}\" is already rotated" if source_rotated?
-
-        nil
-      end
-
-      def source_rotated?
-        source_basename_without_extension.match(/[PN]\d{4}\z/)
-      end
-
-      def source_extension_uncached
-        file_extension(::File.basename(source_path))
-      end
-
-      def source_basename_without_extension
-        ::File.basename(source_path, source_extension)
-      end
-
-      def target_path_uncached
-        ::File.join(dirname, target_basename)
-      end
-
-      def dirname
-        ::File.dirname(source_path)
-      end
-
-      def target_basename
-        source_basename_without_extension + target_suffix + source_extension
-      end
-
-      def target_suffix
-        return '_UNKNOWN_MTIME' unless ::File.exist?(source_path)
-
-        t = ::File.mtime(source_path)
-        t.strftime('_%Y-%m-%d_%H-%M-%S_') + t.strftime('%z').gsub(/\A\+/, 'P').gsub(/\A\-/, 'N')
-      end
-
-      def file_extension(basename)
-        extension = ::File.extname(basename)
-        return '' if extension.blank?
-
-        file_extension(::File.basename(basename, extension)) + extension
-      end
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'active_support/callbacks'
-
-module Avm
-  module Data
-    class Unit
-      include ::ActiveSupport::Callbacks
-
-      define_callbacks :dump, :load
-      enable_speaker
-
-      %w[dump load].each do |action|
-        method_name = "#{action}_command"
-        class_eval <<~CODE, __FILE__, __LINE__ + 1
-          # Should be overrided.
-          # @return [EacRubyUtils::Envs::Command]
-          def #{method_name}
-            fail "\\"#{method_name}\\" is a abstract method. Override in #{singleton_class}."
-          end
-        CODE
-
-        # Callbacks
-        %w[before after].each do |callback|
-          method = "#{callback}_#{action}"
-          class_eval <<~CODE, __FILE__, __LINE__ + 1
-            def self.#{method}(callback_method = nil, &block)
-              if callback_method
-                set_callback :#{action}, :#{callback}, callback_method
-              else
-                set_callback :#{action}, :#{callback}, &block
-              end
-              self
-            end
-
-            def #{method}(callback_method = nil, &block)
-              singleton_class.#{method}(callback_method, &block)
-              self
-            end
-          CODE
-        end
-      end
-
-      def extension
-        singleton_class.const_get('EXTENSION')
-      rescue NameError
-        ''
-      end
-
-      def name
-        self.class
-      end
-
-      def load_from_directory(directory, identifier)
-        load(unit_on_directory_path(directory, identifier))
-      end
-
-      def dump_to_directory(directory, identifier)
-        dump(unit_on_directory_path(directory, identifier))
-      end
-
-      def dump(data_path)
-        run_callbacks :dump do
-          infom "Dumping unit \"#{name}\" to \"#{data_path}\"..."
-          do_dump(data_path)
-        end
-      end
-
-      def load(data_path)
-        run_callbacks :load do
-          infom "Loading unit \"#{name}\" from \"#{data_path}\"..."
-          do_load(data_path)
-        end
-      end
-
-      protected
-
-      def do_dump(data_path)
-        dump_command.execute!(output_file: data_path)
-      end
-
-      def do_load(data_path)
-        load_command.execute!(input_file: data_path)
-      end
-
-      private
-
-      def unit_on_directory_path(directory, identifier)
-        ::File.join(directory, "#{identifier}#{extension}")
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/docker/container.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_docker/executables'
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Docker
-    class Container
-      enable_speaker
-      common_constructor :instance
-
-      def remove
-        ::EacDocker::Executables.docker.command.append(
-          ['rm', '--force', instance.docker_container_name]
-        ).system!
-      end
-
-      def run(options = {})
-        infov 'Container name', instance.docker_container_name
-        infov 'Container exist?', instance.docker_container_exist?
-        remove if options[:clear] && instance.docker_container_exist?
-        if instance.docker_container_exist?
-          run_start
-        else
-          run_run(options)
-        end
-      end
-
-      def run_run(options)
-        infom "\"docker run #{instance.docker_container_name}...\""
-        ::EacDocker::Executables.docker.command.append(run_run_arguments(options)).system!
-      end
-
-      def run_start
-        infom "\"docker start #{instance.docker_container_name}...\""
-        ::EacDocker::Executables.docker.command.append(run_start_arguments).system!
-      end
-
-      def run_run_arguments(options)
-        entrypoint_args = options[:entrypoint_args].if_present([])
-        ['run', '-it', '--name', instance.docker_container_name] + instance.docker_run_arguments +
-          [instance.docker_image.tag] + entrypoint_args
-      end
-
-      def run_start_arguments
-        ['start', '-ai', instance.docker_container_name]
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/docker/image.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/version'
-require 'eac_ruby_utils/core_ext'
-require 'eac_docker/images/templatized'
-
-module Avm
-  module Docker
-    class Image < ::EacDocker::Images::Templatized
-      attr_reader :registry
-      attr_accessor :snapshot
-      attr_accessor :version
-
-      def initialize(registry)
-        @registry = registry
-        self.snapshot = true
-        self.version = true
-      end
-
-      def build(extra_args = [])
-        nyi "Extra args: #{extra_args}" if extra_args.any?
-
-        provide
-      end
-
-      def generator_version
-        ::Avm::VERSION
-      end
-
-      def push
-        ::EacDocker::Executables.docker.command.append(['push', tag]).system!
-      end
-
-      def read_entry(path, options = {})
-        method = path.gsub('.', '_')
-        return send(method) if respond_to?(path, true)
-        return instance.read_entry(path, options) if respond_to?(:instance)
-
-        raise "Method \"#{method}\" not found for entry \"#{path}\""
-      end
-
-      def run(instance)
-        run_run(instance) if container_exist?(instance)
-      end
-
-      def tag
-        r = tag_name
-        r += ":#{tag_version}" if tag_version.present?
-        r
-      end
-
-      def tag_name
-        return registry.name if registry.name.present?
-
-        raise 'Registry name is blank'
-      end
-
-      def tag_version
-        [tag_version_version, stereotype_tag].reject(&:blank?).join('_')
-      end
-
-      def tag_version_version
-        return nil unless version
-
-        r = generator_version
-        r += '-snapshot' if snapshot
-        r
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_docker/registry'
-require 'eac_ruby_utils/core_ext'
-
-module Avm
-  module Docker
-    class Runner
-      DOCKER_DEFAULT_REGISTRY_METHOD = :docker_default_registry
-
-      enable_speaker
-      enable_simple_cache
-
-      runner_with :help do
-        desc 'Manipulate Docker images.'
-        bool_opt '-I', '--image-name', 'Output image name.'
-        arg_opt '-n', '--registry-name', 'Docker registry\'s name.'
-        bool_opt '-p', '--push', 'Push the image to Docker registry.'
-        bool_opt '-r', '--run', 'Run or start a container with builded image.'
-        arg_opt '-B', '--build-arg', 'Argument for "docker build".', repeat: true
-        arg_opt '-E', '--entrypoint-arg', 'Argument for entrypoint on "docker run"', repeat: true
-        bool_opt '-c', '--clear', 'Remove container if exist before run.'
-        bool_opt '-S', '--no-snapshot', 'Does not add "-snapshot" to image tag.'
-        bool_opt '-V', '--no-version', 'Does not add version to image tag.'
-      end
-
-      def run
-        setup
-        banner
-        build
-        output_image_name
-        push
-        container_run
-      end
-
-      private
-
-      def setup
-        instance.docker_image_options = {
-          registry: registry,
-          snapshot: snapshot?,
-          version: version?
-        }
-      end
-
-      def banner
-        infov 'Registry name', registry
-        infov 'Version?', version?
-        infov 'Snapshot?', snapshot?
-        infov 'Image name', docker_image.tag
-        infov 'Build arguments', build_args
-        infov 'Entrypoint arguments', entrypoint_args
-      end
-
-      def build
-        docker_image.build(build_args)
-        success 'Docker image builded'
-      end
-
-      def build_args
-        parsed.build_arg
-      end
-
-      def docker_container
-        instance.docker_container
-      end
-
-      def docker_image
-        instance.docker_image
-      end
-
-      def entrypoint_args
-        parsed.entrypoint_arg
-      end
-
-      def push
-        docker_image.push if parsed.push?
-      end
-
-      def container_run
-        return unless parsed.run?
-
-        docker_container.run(
-          entrypoint_args: entrypoint_args,
-          clear: parsed.clear?
-        )
-      end
-
-      def output_image_name
-        return unless parsed.image_name
-
-        out(docker_image.tag.to_s.strip + "\n")
-      end
-
-      def registry_uncached
-        registry_from_option || registry_from_instance || registry_from_default ||
-          fatal_error('No registry defined')
-      end
-
-      def registry_from_option
-        parsed.registry_name.if_present { |v| ::EacDocker::Registry.new(v) }
-      end
-
-      def registry_from_instance
-        instance.docker_registry_optional.if_present { |v| ::EacDocker::Registry.new(v) }
-      end
-
-      def registry_from_default
-        if_respond(DOCKER_DEFAULT_REGISTRY_METHOD, nil)
-      end
-
-      def snapshot?
-        !parsed.no_snapshot?
-      end
-
-      def version?
-        !parsed.no_version?
-      end
-
-      def instance
-        runner_context.call(:instance)
-      end
-    end
-  end
-end

data/sub/avm/lib/avm/docker.rb

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

data/sub/avm/lib/avm/executables.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs'
-require 'eac_ruby_utils/simple_cache'
-
-module Avm
-  module Executables
-    class << self
-      include ::EacRubyUtils::SimpleCache
-
-      def env
-        ::EacRubyUtils::Envs.local
-      end
-
-      private
-
-      %w[file git js-beautify latex php-cs-fixer tidy yapf xdg-open].each do |program|
-        define_method(program.underscore + '_uncached') do
-          env.executable(program, '--version')
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/instances/entries'
-
-module Avm
-  module Instances
-    class Application
-      include ::Avm::Instances::Entries
-
-      attr_reader :id
-
-      def initialize(id)
-        @id = id.to_s
-      end
-
-      def to_s
-        id
-      end
-
-      def instance(suffix)
-        ::Avm::Instances::Base.new(self, suffix)
-      end
-
-      def name
-        entry(::Avm::Instances::EntryKeys::NAME).read
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Instances
-    class Base
-      module AutoValues
-        module Access
-          def auto_access
-            read_entry_optional('ssh.url').present? ? 'ssh' : 'local'
-          end
-
-          def auto_ssh_hostname
-            inherited_entry_value(::Avm::Instances::EntryKeys::HOST_ID, 'ssh.hostname')
-          end
-
-          def auto_ssh_port
-            inherited_entry_value(::Avm::Instances::EntryKeys::HOST_ID, 'ssh.port') || 22
-          end
-
-          def auto_ssh_username
-            inherited_entry_value(::Avm::Instances::EntryKeys::HOST_ID, 'ssh.username')
-          end
-
-          def auto_ssh_url
-            inherited_entry_value(::Avm::Instances::EntryKeys::HOST_ID, 'ssh.url') ||
-              auto_ssh_url_by_parts
-          end
-
-          def auto_ssh_url_by_parts
-            read_entry_optional('ssh.hostname').if_present do |a|
-              a = read_entry_optional('ssh.username').if_present(a) { |v| "#{v}@#{a}" }
-              a = read_entry_optional('ssh.port').if_present(a) { |v| "#{a}:#{v}" }
-              "ssh://#{a}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Instances
-    class Base
-      module AutoValues
-        module Admin
-          def auto_admin_email
-            inherited_entry_value(::Avm::Instances::EntryKeys::HOST_ID, 'admin.email')
-          end
-
-          def auto_admin_name
-            inherited_entry_value(::Avm::Instances::EntryKeys::HOST_ID, 'admin.name')
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/data/package/dump'
-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}#{::Avm::Data::Instance::Package::Dump::DEFAULT_FILE_EXTENSION}"
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/instances/entry_keys'
-
-module Avm
-  module Instances
-    class Base
-      module AutoValues
-        module Database
-          DEFAULT_EXTRA = ''
-          DEFAULT_HOSTNAME = '127.0.0.1'
-          DEFAULT_LIMIT = 5
-          DEFAULT_PORTS = {
-            'postgresql' => 5432,
-            'mysql' => 3306,
-            'oracle' => 1521,
-            'sqlserver' => 1433
-          }.freeze
-          DEFAULT_SYSTEM = 'postgresql'
-          DEFAULT_TIMEOUT = 5000
-
-          def auto_database_extra
-            database_auto_common('hostname') || DEFAULT_EXTRA
-          end
-
-          def auto_database_name
-            inherited_entry_value(::Avm::Instances::EntryKeys::DATABASE_ID,
-                                  ::Avm::Instances::EntryKeys::DATABASE_NAME) || id
-          end
-
-          def auto_database_hostname
-            database_auto_common('hostname') || DEFAULT_HOSTNAME
-          end
-
-          def auto_database_limit
-            database_auto_common('limit') || DEFAULT_LIMIT
-          end
-
-          def auto_database_password
-            database_auto_common('password') || id
-          end
-
-          def auto_database_port
-            database_auto_common('port') || database_port_by_system
-          end
-
-          def auto_database_username
-            database_auto_common('username') || id
-          end
-
-          def auto_database_system
-            database_auto_common('system') || DEFAULT_SYSTEM
-          end
-
-          def auto_database_timeout
-            database_auto_common('timeout') || DEFAULT_TIMEOUT
-          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::HOST_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