avm-tools 0.110.0 → 0.111.0

data/vendor/avm/Gemfile

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gemspec

data/vendor/avm/avm.gemspec

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.push File.expand_path('lib', __dir__)
-
-require 'avm/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'avm'
-  s.version     = Avm::VERSION
-  s.authors     = ['Eduardo H. Bogoni']
-  s.summary     = 'Ruby base library for Agora Vai! Methodology (https://avm.esquiloazul.tech).'
-
-  s.files = Dir['{lib}/**/*']
-
-  s.add_dependency 'eac_cli', '~> 0.23', '>= 0.23.1'
-  s.add_dependency 'eac_docker', '~> 0.3'
-  s.add_dependency 'eac_git', '~> 0.6'
-  s.add_dependency 'eac_ruby_utils', '~> 0.77'
-  s.add_dependency 'eac_templates', '~> 0.1', '>= 0.1.1'
-  s.add_dependency 'filesize', '~> 0.2'
-  s.add_dependency 'htmlbeautifier', '~> 1.3', '>= 1.3.1'
-  s.add_dependency 'minitar', '~> 0.9'
-
-  s.add_development_dependency 'aranha-parsers', '~> 0.7', '>= 0.7.2'
-  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'
-end

data/vendor/avm/lib/avm/data/instance/files_unit.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/data/instance/unit'
-
-module Avm
-  module Data
-    module Instance
-      class FilesUnit < ::Avm::Data::Instance::Unit
-        EXTENSION = '.tar.gz'
-
-        attr_reader :fs_path_subpath
-
-        def initialize(instance, fs_path_subpath)
-          super(instance)
-          @fs_path_subpath = fs_path_subpath
-        end
-
-        before_load :clear_files
-
-        def files_path
-          ::File.join(instance.read_entry(::Avm::Instances::EntryKeys::FS_PATH), fs_path_subpath)
-        end
-
-        def dump_command
-          instance.host_env.command('tar', '-czf', '-', '-C', files_path, '.')
-        end
-
-        def load_command
-          instance.host_env.command('tar', '-xzf', '-', '-C', files_path)
-        end
-
-        def clear_files
-          infom "Removing all files under #{files_path}..."
-          instance.host_env.command('mkdir', '-p', files_path).execute!
-          instance.host_env.command('find', files_path, '-mindepth', 1, '-delete').execute!
-        end
-      end
-    end
-  end
-end

data/vendor/avm/lib/avm/data/instance/package.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/data/package'
-
-module Avm
-  module Data
-    module Instance
-      class Package < ::Avm::Data::Package
-        attr_reader :instance
-
-        def initialize(instance, options = {})
-          @instance = instance
-          super options
-        end
-      end
-    end
-  end
-end

data/vendor/avm/lib/avm/data/instance/unit.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/data/unit'
-
-module Avm
-  module Data
-    module Instance
-      class Unit < ::Avm::Data::Unit
-        attr_reader :instance
-
-        def initialize(instance)
-          @instance = instance
-        end
-      end
-    end
-  end
-end

data/vendor/avm/lib/avm/data/instance.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/require_sub'
-::EacRubyUtils.require_sub(__FILE__)
-
-module Avm
-  module Data
-    module Instance
-    end
-  end
-end

data/vendor/avm/lib/avm/data/package/dump.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/data/rotate'
-require 'eac_ruby_utils/core_ext'
-require 'minitar'
-
-module Avm
-  module Data
-    class Package
-      class Dump
-        enable_speaker
-        enable_listable
-
-        DEFAULT_EXPIRE_TIME = 1.day
-        DEFAULT_FILE_EXTENSION = '.tar'
-
-        attr_reader :package, :data_file_path, :existing
-
-        lists.add_string :existing, :denied, :overwrite, :rotate, :rotate_expired
-
-        def initialize(package, data_file_path, options = {})
-          @package = package
-          @data_file_path = data_file_path
-          options = options.to_options_consumer
-          @existing, @expire_time = options.consume(:existing, :expire_time)
-          options.validate
-          self.class.lists.existing.value_validate!(@existing)
-        end
-
-        def runnable?
-          cannot_run_reason.blank?
-        end
-
-        def cannot_run_reason
-          return nil if !data_file_exist? ||
-                        [EXISTING_OVERWRITE, EXISTING_ROTATE].include?(existing)
-
-          if existing == EXISTING_DENIED
-            'Data exist and overwriting is denied'
-          elsif existing == EXISTING_ROTATE_EXPIRED && !data_file_expired?
-            'Data exist and yet is not expired'
-          end
-        end
-
-        def run
-          raise "Cannot run: #{cannot_run_reason}" unless runnable?
-
-          build_dir = dump_units_to_build_directory
-          package_file = create_package_file(build_dir)
-          rotate
-          move_download_to_final_dest(package_file)
-        end
-
-        def data_file_exist?
-          ::File.exist?(data_file_path)
-        end
-
-        def data_file_time
-          data_file_exist? ? ::Time.now - ::File.mtime(data_file_path) : nil
-        end
-
-        def data_file_expired?
-          data_file_time.if_present(false) { |v| v >= expire_time }
-        end
-
-        def expire_time
-          @expire_time || DEFAULT_EXPIRE_TIME
-        end
-
-        private
-
-        def download
-          infom 'Downloading dump...'
-          download_path = find_download_path
-          dump_command.system!(output_file: download_path)
-          fatal_error "File \"#{download_path}\" not saved" unless ::File.exist?(download_path)
-          fatal_error "File \"#{download_path}\" is empty" if ::File.zero?(download_path)
-          download_path
-        end
-
-        def move_download_to_final_dest(download_path)
-          ::FileUtils.mkdir_p(::File.dirname(data_file_path))
-          ::FileUtils.mv(download_path, data_file_path)
-        end
-
-        def rotate
-          return unless data_file_exist?
-          return unless existing == EXISTING_ROTATE
-
-          infom "Rotating \"#{data_file_path}\"..."
-          ::Avm::Data::Rotate.new(data_file_path).run
-        end
-
-        def new_build_path
-          f = ::Tempfile.new(self.class.name.parameterize + '-download')
-          path = f.path
-          f.close
-          f.unlink
-          path
-        end
-
-        def dump_units_to_build_directory
-          dir = ::Dir.mktmpdir
-          package.dump_units_to_directory(dir)
-          dir
-        end
-
-        def create_package_file(build_dir)
-          package_path = new_build_path
-          infom "Creating package \"#{package_path}\" from \"#{build_dir}\"..."
-          Dir.chdir(build_dir) do
-            ::Minitar.pack('.', File.open(::File.expand_path(package_path), 'wb'))
-          end
-          package_path
-        end
-      end
-    end
-  end
-end

data/vendor/avm/lib/avm/data/package/load.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'minitar'
-
-module Avm
-  module Data
-    class Package
-      class Load
-        enable_speaker
-
-        attr_reader :package, :data_file_path
-
-        def initialize(package, data_file_path)
-          @package = package
-          @data_file_path = data_file_path
-        end
-
-        def runnable?
-          cannot_run_reason.blank?
-        end
-
-        def cannot_run_reason
-          return nil if data_file_exist?
-
-          "Data file \"#{data_file_path}\" does not exist"
-        end
-
-        def run
-          raise "Cannot run: #{cannot_run_reason}" unless runnable?
-
-          build_dir = extract_packages_to_build_directory
-          package.load_units_from_directory(build_dir)
-        end
-
-        def data_file_exist?
-          ::File.exist?(data_file_path)
-        end
-
-        def extract_packages_to_build_directory
-          dir = ::Dir.mktmpdir
-          ::Minitar.unpack(data_file_path, dir)
-          dir
-        end
-      end
-    end
-  end
-end

data/vendor/avm/lib/avm/data/package.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/data/package/dump'
-require 'avm/data/package/load'
-
-module Avm
-  module Data
-    class Package
-      attr_reader :units
-
-      def initialize(options)
-        @units = {}
-        options = options.to_options_consumer
-        units = options.consume(:units)
-        options.validate
-        units.if_present do |v|
-          v.each { |identifier, unit| add_unit(identifier, unit) }
-        end
-      end
-
-      def add_unit(identifier, unit)
-        @units[identifier.to_sym] = unit
-      end
-
-      def dump(data_path, options = {})
-        ::Avm::Data::Package::Dump.new(self, data_path, options)
-      end
-
-      def load(data_path)
-        ::Avm::Data::Package::Load.new(self, data_path)
-      end
-
-      def dump_units_to_directory(directory)
-        @units.each { |identifier, unit| unit.dump_to_directory(directory, identifier) }
-      end
-
-      def load_units_from_directory(directory)
-        @units.each { |identifier, unit| unit.load_from_directory(directory, identifier) }
-      end
-    end
-  end
-end

data/vendor/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/vendor/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/vendor/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/vendor/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