eac_tools 0.97.2 → 0.99.0

data/sub/avm/lib/avm/applications/base/publishing.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'avm/registry'
+require 'eac_ruby_utils'
+
+module Avm
+  module Applications
+    class Base
+      module Publishing
+        PUBLISHABLE_KEY = 'publishable'
+
+        def publishable?
+          publishable_value ? true : false
+        end
+
+        def stereotype_publishable?(stereotype)
+          return publishable? unless publishable_value.is_a?(::Hash)
+
+          parse_publishable_value(publishable_value[stereotype.stereotype_name], true)
+        end
+
+        private
+
+        def publishable_value
+          parse_publishable_value(entry(PUBLISHABLE_KEY).optional_value, false)
+        end
+
+        def parse_publishable_value(value, hash_to_true)
+          return value.with_indifferent_access if parse_publishable_value_hash?(value, hash_to_true)
+          return true if value.nil? || value == true
+          return false if value == false || value.is_a?(::EacRubyUtils::BlankNotBlank)
+
+          value ? true : false
+        end
+
+        def parse_publishable_value_hash?(value, hash_to_true)
+          !hash_to_true && value.is_a?(::Hash)
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/applications/base/scm.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avm/registry'
+require 'eac_ruby_utils'
+
+module Avm
+  module Applications
+    class Base
+      module Scm
+        common_concern do
+          uri_components_entries_values 'scm', %w[repos_path ssh_username type]
+        end
+
+        # @return [Avm::ApplicationScms::Base]
+        def scm
+          @scm ||= ::Avm::Registry.application_scms.detect(self)
+        end
+
+        # @param value [String]
+        # @return [String]
+        def scm_repos_path_inherited_value_proc(value)
+          value.to_pathname.join(id).to_path
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/applications/base/stereotype.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'avm/registry'
+
+module Avm
+  module Applications
+    class Base
+      module Stereotype
+        # @return [Avm::ApplicationStereotypes::Base, nil]
+        def stereotype_by_configuration
+          entry('stereotype').optional_value.if_present do |v|
+            ::Avm::Registry.application_stereotypes.detect(v)
+          end
+        end
+
+        # @return [Avm::ApplicationStereotypes::Base, nil]
+        def stereotype_by_source
+          ::Avm::Registry.application_stereotypes.detect_optional(local_source.class)
+        end
+
+        private
+
+        # @return [Avm::ApplicationStereotypes::Base]
+        def stereotype_uncached
+          stereotype_by_configuration || stereotype_by_source ||
+            raise("Could not find stereotype for application \"#{self}\"")
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/applications/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'avm/entries/base'
+require 'eac_ruby_utils'
+
+module Avm
+  module Applications
+    class Base
+      enable_simple_cache
+      include ::Avm::Entries::Base
+
+      AVM_TYPE = 'Application'
+
+      class << self
+        # @param id [String]
+        # @return [Avm::Applications::Base]
+        def by_id(id)
+          new(id)
+        end
+      end
+
+      common_constructor :id do
+        self.id = id.to_s
+      end
+
+      def to_s
+        id
+      end
+
+      def instance(suffix)
+        stereotype.instance_class.new(self, suffix)
+      end
+
+      require_sub __FILE__, include_modules: true
+    end
+  end
+end

data/sub/avm/lib/avm/applications.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+
+module Avm
+  module Applications
+  end
+end

data/sub/avm/lib/avm/data/callbacks.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'active_support/callbacks'
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    module Callbacks
+      common_concern do
+        include ::ActiveSupport::Callbacks
+
+        %i[dump load].each do |action|
+          define_callbacks action
+
+          %i[before after].each do |callback|
+            method_name = "#{callback}_#{action}"
+            singleton_class.class_eval do
+              define_method method_name do |callback_method = nil, &block|
+                if callback_method
+                  set_callback action, callback, callback_method
+                else
+                  set_callback action, callback, &block
+                end
+                self
+              end
+            end
+
+            define_method method_name do |callback_method = nil, &block|
+              singleton_class.send(method_name, callback_method, &block)
+              self
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/clearer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'avm/data/performer'
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    class Clearer < ::Avm::Data::Performer
+      def cannot_perform_reason
+        nil
+      end
+
+      protected
+
+      def internal_perform
+        data_owner.clear(*include_excludes_arguments)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/dumper.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'avm/data/performer'
+require 'avm/data/rotate'
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    class Dumper < ::Avm::Data::Performer
+      DEFAULT_EXPIRE_TIME = 1.day
+      DEFAULT_OVERWRITE = false
+      DEFAULT_ROTATE = true
+
+      enable_speaker
+      enable_listable
+      immutable_accessor :expire_time, :target_path
+      immutable_accessor :overwrite, :rotate, type: :boolean
+
+      # @return [nil]
+      def cannot_perform_reason
+        nil
+      end
+
+      # @return [Pathname]
+      def default_dump_path
+        r = data_owner.data_default_dump_path
+        include_excludes_path_suffix.if_present(r) do |v|
+          r.basename_sub('.*') { |b| "#{b}#{v}#{r.extname}" }
+        end
+      end
+
+      # @return [Boolean]
+      def target_path_expired?
+        target_path_time.if_present(true) { |v| v >= expire_time }
+      end
+
+      # @return [ActiveSupport::Duration, nil]
+      def target_path_time
+        target_path.exist? ? ::Time.now - ::File.mtime(target_path) : nil
+      end
+
+      protected
+
+      attr_reader :temp_data_path
+
+      # @return [Array<Symbol>]
+      def all_units
+        data_owner.units.keys.sort
+      end
+
+      def build_temp_data_file
+        data_owner.dump(temp_data_path, *include_excludes_arguments)
+        raise "\"#{temp_data_path}\" do not exist" unless temp_data_path.exist?
+        raise "\"#{temp_data_path}\" is not a file" unless temp_data_path.file?
+      end
+
+      # @return [String, nil]
+      def do_rotate
+        return unless target_path.exist?
+        return unless rotate?
+
+        infom "Rotating \"#{target_path}\"..."
+        ::Avm::Data::Rotate.new(target_path).run
+      end
+
+      # @return [Array<Symbol>]
+      def excluded_units
+        excludes.map(&:to_sym).sort
+      end
+
+      # @return [ActiveSupport::Duration]
+      def expire_time_get_filter(value)
+        value || DEFAULT_EXPIRE_TIME
+      end
+
+      # @return [String]
+      def include_excludes_path_suffix
+        return nil unless data_owner.respond_to?(:units)
+
+        r = included_units.any? ? included_units : all_units
+        r -= excluded_units if excluded_units.any?
+        r.any? && r != all_units ? "_#{r.join('-')}" : ''
+      end
+
+      # @return [Array<Symbol>]
+      def included_units
+        includes.map(&:to_sym).sort
+      end
+
+      # @return [self]
+      def internal_perform
+        use_current? ? internal_perform_use_current : internal_perform_new
+      end
+
+      def internal_perform_new
+        on_temp_data_file do
+          build_temp_data_file
+          do_rotate
+          move_data_to_target_path
+        end
+      end
+
+      def internal_perform_use_current
+        infom "Dump \"#{target_path}\" exists and is unexpired"
+      end
+
+      def move_data_to_target_path
+        ::FileUtils.mv(temp_data_path, target_path.assert_parent)
+      end
+
+      def on_temp_data_file
+        ::EacRubyUtils::Fs::Temp.on_file do |file|
+          @temp_data_path = file.to_pathname
+          yield
+        end
+      end
+
+      # @return [Boolean]
+      def overwrite_get_filter(value)
+        value.nil? ? DEFAULT_OVERWRITE : value
+      end
+
+      def rotate_get_filter(value)
+        value.nil? ? DEFAULT_ROTATE : value
+      end
+
+      # @return [Pathname]
+      def target_path_get_filter(value)
+        (value || default_dump_path).to_pathname
+      end
+
+      # @return [Boolean]
+      def use_current?
+        return false unless target_path.exist?
+        return false if overwrite?
+
+        !target_path_expired?
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/loader.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avm/data/performer'
+require 'avm/data/rotate'
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    class Loader < ::Avm::Data::Performer
+      immutable_accessor :source_path
+
+      # @return [String, nil]
+      def cannot_perform_reason
+        return 'Source path not set' if source_path.blank?
+        return "\"#{source_path}\" is not a file" unless source_path.file?
+
+        nil
+      end
+
+      protected
+
+      def internal_perform
+        data_owner.load(source_path, *include_excludes_arguments)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package/base_performer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    class Package
+      class BasePerformer
+        acts_as_abstract :result
+        enable_speaker
+        enable_listable
+        lists.add_symbol :option, :excludes, :includes
+        common_constructor :package, :options, default: [{}] do
+          self.options = ::Avm::Data::Package::BasePerformer.lists.option
+                           .hash_keys_validate!(options)
+        end
+
+        # @return [Set<Symbol>]
+        def excludes
+          ::Set.new((options[OPTION_EXCLUDES] || []).map(&:to_sym))
+        end
+
+        # @return [Set<Symbol>]
+        def includes
+          ::Set.new((options[OPTION_INCLUDES] || []).map(&:to_sym))
+        end
+
+        # @return [Hash<Symbol, Avm::Data::Unit]
+        def selected_units
+          r = package.units
+          r = r.slice(*includes.to_a) if includes.any?
+          r = r.except(*excludes.to_a) if excludes.any?
+          r
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package/build_directory.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    class Package
+      module BuildDirectory
+        private
+
+        attr_writer :build_directory
+
+        # @return [EacRubyUtils::Fs::Temp::Directory]
+        def build_directory
+          @build_directory || raise('@build_directory is blank')
+        end
+
+        def on_build_directory
+          ::EacRubyUtils::Fs::Temp.on_directory do |directory|
+            self.build_directory = directory
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package/clear.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'avm/data/package/base_performer'
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    class Package
+      class Clear < ::Avm::Data::Package::BasePerformer
+        enable_method_class
+
+        # @return [void]
+        def result
+          selected_units.each do |identifier, unit|
+            infov 'Clearing unit', identifier
+            unit.clear
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'avm/data/package/base_performer'
+require 'avm/data/package/build_directory'
+require 'eac_ruby_utils'
+require 'minitar'
+
+module Avm
+  module Data
+    class Package
+      class Dump < ::Avm::Data::Package::BasePerformer
+        enable_method_class
+        include ::Avm::Data::Package::BuildDirectory
+
+        attr_reader :target_path
+
+        def initialize(package, target_path, options = {})
+          super(package, options)
+          @target_path = target_path.to_pathname
+        end
+
+        # @return [void]
+        def result
+          on_build_directory do
+            dump_units_to_build_directory
+            create_package_file
+          end
+        end
+
+        protected
+
+        def dump_units_to_build_directory
+          package.dump_units_to_directory(build_directory, selected_units)
+        end
+
+        def create_package_file
+          infom "Creating package \"#{target_path}\" from \"#{build_directory}\"..."
+          ::Dir.chdir(build_directory.to_path) do
+            ::Minitar.pack('.', ::File.open(target_path, 'wb'))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'avm/data/package/base_performer'
+require 'avm/data/package/build_directory'
+require 'eac_ruby_utils'
+require 'minitar'
+
+module Avm
+  module Data
+    class Package
+      class Load < ::Avm::Data::Package::BasePerformer
+        enable_method_class
+        enable_speaker
+        include ::Avm::Data::Package::BuildDirectory
+
+        attr_reader :source_path
+
+        def initialize(package, source_path, options = {})
+          super(package, options)
+          @source_path = source_path.to_pathname
+        end
+
+        def result
+          on_build_directory do
+            extract_packages_to_build_directory
+            package.load_units_from_directory(build_directory, selected_units)
+          end
+        end
+
+        def extract_packages_to_build_directory
+          ::Minitar.unpack(source_path.to_path, build_directory.to_path)
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/package.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'avm/data/callbacks'
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    class Package
+      require_sub __FILE__, require_mode: :kernel
+      include ::Avm::Data::Callbacks
+
+      DATA_FILE_EXTENSION = '.tar'
+
+      def initialize(options)
+        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
+
+      # @return [Avm::Data::Package] Return +self+.
+      def add_unit(identifier, unit)
+        units[identifier.to_sym] = unit
+
+        self
+      end
+
+      # @return [String]
+      def data_file_extension
+        DATA_FILE_EXTENSION
+      end
+
+      def dump_units_to_directory(directory, selected_units = nil)
+        run_callbacks :dump do
+          (selected_units || units).each do |identifier, unit|
+            unit.dump_to_directory(directory, identifier)
+          end
+        end
+      end
+
+      def load_units_from_directory(directory, selected_units = nil)
+        run_callbacks :load do
+          (selected_units || units).each do |identifier, unit|
+            unit.load_from_directory(directory, identifier)
+          end
+        end
+      end
+
+      # @param id [Symbol]
+      # @return [Avm::Data::UnitWithCommands]
+      def unit(identifier)
+        units[identifier.to_sym] || raise("No unit found with identifier \"#{identifier}\"")
+      end
+
+      def units
+        @units ||= {}
+      end
+
+      # @return [Enumerable<String>]
+      def units_ids
+        units.keys
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/data/performer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'avm/data/rotate'
+require 'eac_ruby_utils'
+
+module Avm
+  module Data
+    class Performer
+      acts_as_abstract(:cannot_perform_reason, :internal_perform)
+      acts_as_immutable
+      common_constructor :data_owner
+      immutable_accessor :exclude, :include, type: :set
+
+      # @return [Enumerable]
+      def immutable_constructor_args
+        [data_owner]
+      end
+
+      # @return [self]
+      def perform
+        raise "Cannot run: #{cannot_perform_reason}" unless performable?
+
+        internal_perform
+
+        self
+      end
+
+      # @return [Boolean]
+      def performable?
+        cannot_perform_reason.blank?
+      end
+
+      protected
+
+      def include_excludes_arguments
+        options = include_excludes_options
+        options.any? ? [options] : []
+      end
+
+      def include_excludes_options
+        r = {}
+        r[:includes] = includes if includes.any?
+        r[:excludes] = excludes if excludes.any?
+        r
+      end
+    end
+  end
+end