eac_tools 0.86.13 → 0.87.1

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'avm/runners/base'
+require 'eac_cli/core_ext'
+
+module Avm
+  module Instances
+    class Runner < ::Avm::Runners::Base
+      runner_with :help, :subcommands do
+        desc 'Utilities for a instance.'
+        pos_arg 'instance-id'
+        subcommands
+      end
+
+      delegate :class, to: :instance, prefix: true
+      for_context :instance
+
+      def extra_available_subcommands
+        instance.if_present({}, &:extra_available_subcommands)
+      end
+
+      def stereotype_module
+        instance.application.stereotype.namespace_module
+      end
+
+      def stereotype_name
+        stereotype_module.name
+      end
+
+      private
+
+      def instance_uncached
+        parsed.instance_id.if_present { |v| ::Avm::Registry.instances.detect(v) }
+      end
+    end
+  end
+end

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

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

data/sub/avm/lib/avm/launcher/context/instance_collector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceCollector
+        common_constructor :context
+
+        def add_all
+          instances_set.merge(context.instances)
+          self
+        end
+
+        def add_path(path)
+          instances_set.merge(instances_on_path(path))
+          self
+        end
+
+        def add_pending
+          instances_set.merge(context.pending_instances)
+          self
+        end
+
+        def instances
+          instances_set.sort
+        end
+
+        private
+
+        def instance_match?(instance, instance_name)
+          ::File.fnmatch?(instance_name, instance.name)
+        end
+
+        def instances_on_path(path)
+          context.instances.select { |instance| instance_match?(instance, path) }
+        end
+
+        def instances_set
+          @instances_set ||= ::Set.new
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_discovery.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+require 'avm/launcher/instances/base'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceDiscovery
+        attr_reader :instances
+
+        def initialize(context)
+          @context = context
+          @progress = ::ProgressBar.create(title: 'Instance discovery', total: 1)
+          @instances = path_instances(@context.root, nil)
+        ensure
+          @progress&.finish
+        end
+
+        private
+
+        def path_instances(path, parent_instance)
+          update_progress_format(path)
+          on_rescued_path_instances(path) do |r|
+            if path.project?
+              parent_instance = ::Avm::Launcher::Instances::Base.instanciate(path, parent_instance)
+              r << path
+            end
+            children = path.children
+            update_progress_count(children)
+            r.concat(children.flat_map { |c| path_instances(c, parent_instance) })
+          end
+        end
+
+        def on_rescued_path_instances(path)
+          r = []
+          begin
+            yield(r) if path.included?
+          rescue StandardError => e
+            warn("#{path}: #{e}")
+          end
+          r
+        end
+
+        def update_progress_format(path)
+          @progress.format = "%t (Paths: %c/%C, Current: #{path.logical}) |%B| %a"
+        end
+
+        def update_progress_count(children)
+          @progress.total += children.count
+          @progress.increment
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_manager/cached_instance.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/instances/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        class CachedInstance
+          enable_speaker
+          enable_simple_cache
+          common_constructor :cached_instances, :data
+
+          private
+
+          def instance_uncached
+            ::Avm::Launcher::Instances::Base.instanciate(path, parent_instance)
+          rescue ::Avm::Launcher::Errors::NonProject
+            warn "Cached instance \"#{data[:logical]}\" not found"
+            nil
+          end
+
+          def parent_instance_uncached
+            data[:parent]
+              .if_present { |v| cached_instances.by_logical_path(v) }
+              .if_present(&:instance)
+          end
+
+          def path_uncached
+            ::Avm::Launcher::Paths::Logical.from_h(cached_instances.context, data)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_manager/cached_instances.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/context/instance_manager/cached_instance'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        class CachedInstances
+          enable_simple_cache
+          common_constructor :context, :content
+
+          def instances
+            content.keys.map { |k| by_logical_path(k).instance }.compact_blank
+          end
+
+          def by_logical_path(key)
+            cached_instances[key].if_blank do
+              cached_instances[key] = ::Avm::Launcher::Context::InstanceManager::CachedInstance.new(
+                self, content.fetch(key)
+              )
+            end
+          end
+
+          private
+
+          def cached_instances_uncached
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/instance_manager.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/launcher/publish/check_result'
+require('yaml')
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        require_sub __FILE__
+        enable_simple_cache
+        common_constructor :context
+
+        def publish_state_set(instance, stereotype_name, check_status)
+          data = cached_instances_file_content_uncached
+          data[instance.logical] ||= {}
+          data[instance.logical][:publish_state] ||= {}
+          data[instance.logical][:publish_state][stereotype_name] = check_status
+          write_cache_file(data)
+        end
+
+        def pending_instances
+          instances.select { |instance| pending_instance?(instance) }
+        end
+
+        private
+
+        def instances_uncached
+          (cached_instances || search_instances).select(&:included?)
+        end
+
+        def search_instances
+          cache_instances(::Avm::Launcher::Context::InstanceDiscovery.new(context).instances)
+        end
+
+        def cached_instances
+          return nil if context.recache
+          return nil unless cached_instances_file_content
+
+          CachedInstances.new(self, cached_instances_file_content).instances
+        end
+
+        def cached_instances_file_content_uncached
+          r = YAML.load_file(cache_file_path)
+          r.is_a?(::Hash) ? r : nil
+        rescue Errno::ENOENT
+          nil
+        end
+
+        def cache_instances(instances)
+          write_cache_file(instances.to_h { |i| [i.logical, i.to_h] })
+          instances
+        end
+
+        def write_cache_file(data)
+          cache_file_path.to_pathname.parent.mkpath
+          ::File.write(cache_file_path, data.to_yaml)
+        end
+
+        def cache_file_path
+          ::File.join(context.cache_root, 'instances.yml')
+        end
+
+        def pending_instance?(instance)
+          data = cached_instances_file_content
+          return false unless data[instance.logical]
+          return false unless data[instance.logical][:publish_state].is_a?(Hash)
+
+          data[instance.logical][:publish_state].any? do |_k, v|
+            ::Avm::Launcher::Publish::CheckResult.pending_status?(v)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context/settings.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/instances/settings'
+require 'eac_ruby_utils/simple_cache'
+require 'yaml'
+
+module Avm
+  module Launcher
+    class Context
+      class Settings
+        include ::EacRubyUtils::SimpleCache
+
+        def initialize(file)
+          unless ::File.exist?(file)
+            ::FileUtils.mkdir_p(::File.dirname(file))
+            ::File.write(file, {}.to_yaml)
+          end
+          @data = YAML.load_file(file)
+        end
+
+        def instance_settings(instance)
+          ::Avm::Launcher::Instances::Settings.new(value(['Instances', instance.name]))
+        end
+
+        private
+
+        def excluded_projects_uncached
+          enum_value(%w[Projects Exclude])
+        end
+
+        def excluded_paths_uncached
+          enum_value(%w[Paths Exclude])
+        end
+
+        def enum_value(path)
+          r = value(path)
+          r.is_a?(Enumerable) ? r : []
+        end
+
+        def value(path)
+          node_value(@data, path)
+        end
+
+        def node_value(data, path)
+          return data if path.empty?
+          return nil unless data.is_a?(Hash)
+
+          node_value(data[path.first], path.drop(1))
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/context.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'avm/launcher/context/instance_manager'
+require 'eac_fs/contexts'
+require 'eac_fs/core_ext'
+require 'eac_ruby_utils/simple_cache'
+require 'eac_cli/speaker'
+require 'avm/launcher/context/instance_discovery'
+require 'avm/launcher/context/settings'
+require 'avm/launcher/paths/logical'
+require 'avm/launcher/project'
+
+module Avm
+  module Launcher
+    class Context
+      include ::EacRubyUtils::SimpleCache
+      enable_speaker
+
+      class << self
+        attr_writer :current
+
+        def current
+          @current ||= default
+        end
+
+        def default
+          @default ||= Context.new
+        end
+      end
+
+      attr_reader :root, :settings, :cache_root
+      attr_accessor :publish_options, :recache, :instance_manager
+
+      CONFIG_PATH_PREFIX = 'launcher'
+
+      def initialize(options = {})
+        @options = options.with_indifferent_access
+        @root = ::Avm::Launcher::Paths::Logical.new(self, nil, build_option(:projects_root), '/')
+        @settings = ::Avm::Launcher::Context::Settings.new(build_option(:settings_file))
+        @cache_root = build_option(:cache_root)
+        @publish_options = { new: false, confirm: false, stereotype: nil }
+        @instance_manager = ::Avm::Launcher::Context::InstanceManager.new(self)
+        @recache = false
+      end
+
+      def fs_object_id
+        root.real.variableize
+      end
+
+      def instance(name)
+        instances.find { |i| i.name == name }
+      end
+
+      def instances
+        @instance_manager.instances
+      end
+
+      def pending_instances
+        @instance_manager.pending_instances
+      end
+
+      private
+
+      def build_option(key)
+        @options[key] || config_option(key) || default_option(key)
+      end
+
+      def config_option(key)
+        ::Avm::Self::Instance.default.entry([CONFIG_PATH_PREFIX, key].join('.')).optional_value
+      end
+
+      def default_cache_root
+        fs_cache.path
+      end
+
+      def default_option(key)
+        send("default_#{key}".underscore)
+      end
+
+      # @return [String]
+      def default_projects_root
+        '.'.to_pathname.expand_path.to_path
+      end
+
+      def default_settings_file
+        ::File.join(::EacFs::Contexts.config.current.path, 'launcher.yaml')
+      end
+
+      def projects_uncached
+        r = {}
+        instances.each do |i|
+          r[i.project_name] ||= []
+          r[i.project_name] << i
+        end
+        r.map { |name, instances| ::Avm::Launcher::Project.new(name, instances) }
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/errors/base.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Errors
+      class Base < ::StandardError
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/errors/non_project.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/errors/base'
+
+module Avm
+  module Launcher
+    module Errors
+      class NonProject < ::Avm::Launcher::Errors::Base
+        def initialize(path)
+          super("#{path} is not a project")
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/errors.rb

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

data/sub/avm/lib/avm/launcher/instances/base/cache.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Instances
+      module Base
+        module Cache
+          def cache_path(subpath)
+            File.join(cache_root, subpath)
+          end
+
+          def cache_key(key, &block)
+            v = cache_key_get(key)
+            return v if v.present? || block.nil?
+
+            v = yield
+            cache_key_write(key, v)
+            v
+          end
+
+          private
+
+          def cache_key_get(key)
+            File.file?(cache_key_path(key)) ? File.read(cache_key_path(key)) : nil
+          end
+
+          def cache_key_write(key, value)
+            FileUtils.mkdir_p(File.dirname(cache_key_path(key)))
+            File.write(cache_key_path(key), value)
+          end
+
+          def cache_key_path(key)
+            File.join(cache_root, 'keys', key.parameterize)
+          end
+
+          def cache_root
+            File.join(::Avm::Launcher::Context.current.cache_root, name.parameterize)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/launcher/instances/base/publishing.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Instances
+      module Base
+        module Publishing
+          def publish?(stereotype)
+            publish_by_stereotype?(stereotype) && publish_by_application?(stereotype) &&
+              publish_by_context?(stereotype)
+          end
+
+          # @return [Boolean]
+          def publish_by_application?(stereotype)
+            application.stereotype_publishable?(stereotype)
+          end
+
+          # @return [Boolean]
+          def publish_by_context?(stereotype)
+            filter = ::Avm::Launcher::Context.current.publish_options[:stereotype]
+            filter.blank? ? true : filter == stereotype.name.demodulize
+          end
+
+          # @return [Boolean]
+          def publish_by_stereotype?(stereotype)
+            stereotype.publish_class.present?
+          end
+
+          # @return [Boolean]
+          delegate :publishable?, to: :application
+
+          def publish_check
+            stereotypes.each do |s|
+              next unless publish?(s)
+
+              puts "#{name.to_s.cyan}|#{s.label}|" \
+                   "#{s.publish_class.new(self).check}"
+            end
+          end
+
+          def publish_run
+            stereotypes.each do |s|
+              next unless publish?(s)
+
+              infov(name, "publishing #{s.label}")
+              s.publish_class.new(self).run
+            end
+          end
+        end
+      end
+    end
+  end
+end