avm-tools 0.60.0 → 0.62.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a03f7f27fdfdd821203ba28f951ca16404a91b886453f9839e855dcf78627ef
-  data.tar.gz: 8f02cc5b2e5454e4e5253be317e73c94d8f007538b3464281f9a84c1bd83768f
+  metadata.gz: 373072ac50452efe90c4a8408828dff28b48209d5a387709d89972678ab92e21
+  data.tar.gz: 2f09de5ac81af5bc0992c6c3facb97e908001deffcd5d0f17492fc0258aa415c
 SHA512:
-  metadata.gz: dd7d158d5b73aea3e54c715b2a13ec15fa3bc5fd6f87b3252f70ae9b0fd8dce36fb3a6b9c1d043f0b2365087848627595aaf7041142bf27f18d60a3f1ac4e0a9
-  data.tar.gz: a8300831601639f79484dcd81934900c4be5003e85ed4e5a6345bb0c19ea5f4b3149556633238bd63fff97c933df7535622bfe588021c06e0567a064ccaca7e2
+  metadata.gz: 7a9f83824449276c9fedbd9d7ef07aa8e124f8de1d948c477bb9734c57cfbffef29b1416e249edc5de11e5a23ee9d02c982a9e80d6b9a40b9f9b5a011807d27b
+  data.tar.gz: 5a09becd99a994a50fa875ae2566262c461d3f9bd6557b670c8a1e81d59768f736e59bbad5cbea127efb4ae6476d7104347169b13958c0d15dde5a158e41a5de

data/lib/avm/cached_download.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'avm/fs_cache'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  class CachedDownload
+    attr_reader :url, :fs_cache
+
+    def initialize(url, parent_fs_cache = nil)
+      @url = url
+      @fs_cache = (parent_fs_cache || ::Avm.fs_cache).child(url.parameterize)
+    end
+
+    def assert
+      download unless fs_cache.cached?
+    end
+
+    def download
+      ::EacRubyUtils::Fs::Temp.on_file do |temp|
+        download_to(temp)
+        fs_cache.content_path.to_pathname.dirname.mkpath
+        ::FileUtils.mv(temp.to_path, fs_cache.content_path)
+      end
+    end
+
+    def path
+      @path ||= fs_cache.content_path.to_pathname
+    end
+
+    private
+
+    def download_to(local_file)
+      ::URI.parse(url).open do |remote|
+        local_file.open('wb') { |handle| handle.write(remote.read) }
+      end
+    end
+  end
+end

data/lib/avm/eac_redmine_base0/core_update.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'avm/eac_redmine_base0/core_update'
+require 'avm/cached_download'
+require 'avm/sync'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacRedmineBase0
+    class CoreUpdate
+      enable_console_speaker
+      enable_simple_cache
+      common_constructor :instance, :version, :url
+
+      GITIGNORE_ADD = %w[/public/assets/**/* /config/install.sh /log/**/*].freeze
+      GITIGNORE_DEL = %w[/Gemfile.lock /plugins/* /public/themes/*].freeze
+      TARGET_KEEP = %w[/Gemfile.lock].freeze
+
+      def run
+        ::EacRubyUtils::Fs::Temp.on_directory do |dir|
+          @tempdir = dir
+          assert_source_package
+          extract_package_to_tempdir
+          sync_content
+          change_git_ignore
+          validate_empty_dir
+        end
+        git_commit
+        success 'Done!'
+      end
+
+      def assert_source_package
+        infom 'Asserting source package...'
+        source_package.assert
+        infov 'Package cache path', source_package.path
+        infov 'Package size', source_package.path.size
+      end
+
+      private
+
+      attr_reader :tempdir
+
+      def change_git_ignore
+        file = target_path.join('.gitignore')
+        file.write(
+          (file.read.each_line.map(&:strip).reject { |line| GITIGNORE_DEL.include?(line) } +
+            ['', '#eac_redmine_base0'] + GITIGNORE_ADD).map { |line| "#{line}\n" }.join
+        )
+      end
+
+      def extract_package_to_tempdir
+        infom "Extracting package to tempdir #{tempdir}..."
+        ::EacRubyUtils::Envs.local.command(
+          'tar', '-xf', source_package.path.to_path, '-C', tempdir.to_path,
+          '--strip-components', '1'
+        ).execute!
+      end
+
+      def git_commit
+        if git_repo.dirty?
+          infom 'Git commiting...'
+          git_repo.command('add', '--', target_path).execute!
+          git_repo.command('commit', '-m', git_commit_message, '--', target_path).execute!
+        else
+          infom 'Nothing to commit'
+        end
+      end
+
+      def git_commit_message
+        "Core: update to #{version}."
+      end
+
+      def git_repo_uncached
+        ::EacGit::Local.new(target_path)
+      end
+
+      def sync_content
+        ::Avm::Sync.new(source_path, target_path)
+                   .add_exclude('/*').add_includes(*target_files_to_remove).move_mode(true).run
+      end
+
+      def source_package_uncached
+        ::Avm::CachedDownload.new(url, ::Avm.fs_cache.child('eac_redmine_base0', 'core_update'))
+      end
+
+      def validate_empty_dir
+        if source_path.children.empty?
+          infom 'No content left in source directory'
+        else
+          fatal_error 'Found entries in source directory: ' +
+                      source_path.children.map { |c| c.basename.to_path }.join(', ')
+        end
+      end
+
+      def source_path_uncached
+        ::Pathname.new(tempdir.to_path)
+      end
+
+      def target_files_to_remove
+        git_repo.command('ls-files').execute!
+                .each_line.map { |v| "/#{v.strip}" }
+                .without(*TARGET_KEEP)
+      end
+
+      def target_path_uncached
+        instance.read_entry('fs_path').to_pathname
+      end
+    end
+  end
+end

data/lib/avm/eac_redmine_base0/data_unit.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avm/data/instance/unit'
+require 'eac_ruby_utils/core_ext'
+require 'open-uri'
+
+module Avm
+  module EacRedmineBase0
+    class DataUnit < ::Avm::Data::Instance::Unit
+      common_constructor :instance
+
+      EXTENSION = '.tar'
+
+      def do_dump(data_path)
+        ::File.open(data_path, 'wb') do |file|
+          file << URI.parse(export_url).read
+        end
+      end
+
+      def export_url
+        uri = ::Addressable::URI.parse(instance.read_entry('web.url')) + '/backup/export'
+        uri.query_values = { key: instance.read_entry('admin.api_key') }
+        uri.to_s
+      end
+    end
+  end
+end

data/lib/avm/eac_redmine_base0/deploy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'avm/stereotypes/eac_webapp_base0/deploy'
+require 'eac_ruby_utils/ruby'
+
+module Avm
+  module EacRedmineBase0
+    class Deploy < ::Avm::Stereotypes::EacWebappBase0::Deploy
+      set_callback :assert_instance_branch, :after, :run_installer
+
+      def run_installer
+        infom 'Running installer'
+        ::EacRubyUtils::Ruby.on_clean_environment do
+          installer_command.system!
+        end
+      end
+
+      def installer_command
+        instance.host_env.command(installer_path, install_task)
+      end
+
+      def installer_path
+        ::File.join(instance.read_entry(:fs_path), 'plugins', 'redmine_installer', 'installer',
+                    'run.sh')
+      end
+
+      def install_task
+        if instance.read_entry_optional('web.path').present?
+          'redmine_as_apache_path'
+        else
+          'redmine_as_apache_base'
+        end
+      end
+    end
+  end
+end

data/lib/avm/eac_redmine_base0/instance.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'avm/eac_redmine_base0/data_unit'
+require 'avm/stereotypes/eac_ubuntu_base0/docker_image'
+require 'avm/stereotypes/eac_webapp_base0/instance'
+require 'avm/stereotypes/rails/instance'
+
+module Avm
+  module EacRedmineBase0
+    class Instance < ::Avm::Stereotypes::EacWebappBase0::Instance
+      include ::Avm::Stereotypes::Rails::Instance
+
+      FILES_UNITS = { files: 'files' }.freeze
+
+      def docker_image_class
+        ::Avm::Stereotypes::EacUbuntuBase0::DockerImage
+      end
+
+      def docker_run_arguments
+        [
+          '--volume', "#{read_entry(:fs_path)}:/home/myuser/eac_redmine_base0",
+          '--publish', "#{read_entry(:ssh_port)}:22",
+          '--publish', "#{read_entry(:http_port)}:80",
+          '--publish', "#{read_entry(:https_port)}:443"
+        ]
+      end
+
+      def data_package
+        @data_package ||= ::Avm::Data::Instance::Package.new(
+          self,
+          units: {
+            all: ::Avm::EacRedmineBase0::DataUnit.new(self)
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_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(::EacLauncher::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(Hash[instances.map { |i| [i.logical, i.to_h] }])
+          instances
+        end
+
+        def write_cache_file(data)
+          ::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|
+            ::EacLauncher::Publish::CheckResult.pending_status?(v)
+          end
+        end
+      end
+    end
+  end
+end

data/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_console_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
+            ::EacLauncher::Paths::Logical.from_h(cached_instances.context, data)
+          end
+        end
+      end
+    end
+  end
+end

data/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 }.reject(&: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/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/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