avm-tools 0.59.0 → 0.62.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08d973e58416ce742fea0b91630ad75c85c48838f302019cdbd4362594704cb8'
-  data.tar.gz: 6984410c1a7cf6e36f846fa6c388abca39b6b5f9eb8aec359b9bf069cd2d74a8
+  metadata.gz: 023b291269b46cb2a272642eac7febb8cbecd15429aeae61435260d0977c0958
+  data.tar.gz: 4ff8f6c8c50ad54a5f7b84be35780e7a221608c7e955a0cb2e241b6f31aa88e1
 SHA512:
-  metadata.gz: 2d019bdb2a01a137afa8a5e01aeb35b9d29214e185eddad3ab926215bbf0267ca1aa21f57927fea98482f381e09fa52e6ba6497da618bcdcc6f522d7672afa5a
-  data.tar.gz: 17f2e21690f779b7c67405e4397343b13083b8cf8984a8b521031f5f65f8998a0f44062099425e6acb6c9d1a33771a21dd487678afe2929a384f3a6c5a89bfc1
+  metadata.gz: df68926e69e0e8912f73e452fd50b218909620040eb2a69a0695ddce9542f8616e881cd455248df8a9cb89028f6ad9ff9d66aa204c7c79ba0559d317779c2e56
+  data.tar.gz: 155dbcdd721e28b5d4cd021ddb25f35daf4b4f26c2b530cb5ba21377c72ee7a0329a5149831a6031d0c7cfd12e777254b251954774ea7eb9e317b7d57f034f10

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