eac_tools 0.2.1 → 0.4.0

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'avm/launcher/context/instance_manager'
+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'
+require 'avm/tools/self'
+
+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 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
+        ::Avm::Tools::Self.application.cache_dir.join('launcher')
+      end
+
+      def default_option(key)
+        send("default_#{key}".underscore)
+      end
+
+      def default_projects_root
+        '.'
+      end
+
+      def default_settings_file
+        ::Avm::Tools::Self.application.config_dir.join('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-tools/lib/avm/launcher/git/base/class_methods.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Git
+      class Base < ::Avm::Launcher::Paths::Real
+        module ClassMethods
+          # @return [Avm::Launcher::Git::Base]
+          def by_root(search_base_path)
+            new(find_root(search_base_path).to_path)
+          end
+
+          # Searches the root path for the Git repository which includes +search_base_path+.
+          # @return [Pathname]
+          def find_root(search_base_path)
+            path = search_base_path.to_pathname.expand_path
+            loop do
+              return path if path.join('.git').exist?
+              raise "\".git\" not found for \"#{search_base_path}\"" if path.parent.root?
+
+              path = path.parent
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/base/dirty_files.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+
+module Avm
+  module Launcher
+    module Git
+      class Base < ::Avm::Launcher::Paths::Real
+        module DirtyFiles
+          delegate :dirty?, to: :eac_git
+
+          def dirty_files
+            eac_git.dirty_files.map do |df|
+              ::OpenStruct.new(
+                df.to_h.merge(path: df.path.to_path, absolute_path: df.absolute_path.to_path)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/base/remotes.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/launcher/git/remote'
+
+module Avm
+  module Launcher
+    module Git
+      class Base < ::Avm::Launcher::Paths::Real
+        module Remotes
+          # @return [Avm::Launcher::Git::Remote]
+          def remote(name)
+            ::Avm::Launcher::Git::Remote.new(self, name)
+          end
+
+          def remote_hashs(remote_name)
+            remote(remote_name).ls
+          end
+
+          def remote_exist?(remote_name)
+            remote(remote_name).exist?
+          end
+
+          def assert_remote_url(remote_name, url)
+            r = git.remote(remote_name)
+            if !r.url || r.url != url
+              r.remove if r.url
+              git.add_remote(remote_name, url)
+            end
+            r
+          end
+
+          def remote_branch_sha(remote_name, branch_name)
+            remote_hashs(remote_name)["refs/heads/#{branch_name}"]
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/base/subrepo.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+
+module Avm
+  module Launcher
+    module Git
+      class Base < ::Avm::Launcher::Paths::Real
+        module Subrepo
+          def subrepo_status(subrepo_path)
+            s = execute!('subrepo', 'status', subrepo_path.gsub(%r{\A/}, ''))
+            raise s.strip.to_s if s.include?('is not a subrepo')
+
+            r = subrepo_status_parse_output(s)
+            raise "Empty subrepo status for |#{s}|\n" unless r.any?
+
+            r
+          end
+
+          def subrepo_remote_url(subrepo_path)
+            h = subrepo_status(subrepo_path)
+            url = h['Remote URL']
+            return url if url.present?
+
+            raise "Remote URL is blank for subrepo \"#{subrepo_path}\" (Subrepo status: #{h})"
+          end
+
+          private
+
+          def subrepo_status_parse_output(output)
+            r = {}.with_indifferent_access
+            output.each_line do |l|
+              m = /\A([^\:]+)\:(.*)\z/.match(l.strip)
+              next unless m && m[2].present?
+
+              r[m[1].strip] = m[2].strip
+            end
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/base/underlying.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'eac_git/executables'
+require 'eac_ruby_utils/envs'
+require 'git'
+require 'avm/launcher/paths/real'
+
+module Avm
+  module Launcher
+    module Git
+      class Base < ::Avm::Launcher::Paths::Real
+        module Underlying
+          def command(*args)
+            args, options = build_args(args)
+            r = ::EacGit::Executables.git.command(*args)
+            (options[:exit_outputs] || {}).each do |status_code, result|
+              r = r.status_result(status_code, result)
+            end
+            r
+          end
+
+          def execute(*args)
+            command(*args).execute
+          end
+
+          def execute!(*args)
+            command(*args).execute!
+          end
+
+          def system!(*args)
+            command(*args).system!
+          end
+
+          def init
+            git
+            self
+          end
+
+          private
+
+          def build_args(args)
+            options = {}
+            if args.last.is_a?(Hash)
+              options = args.last
+              args.pop
+            end
+            args = args.first if args.first.is_a?(Array)
+            [['-C', self, '--no-pager'] + args, options]
+          end
+
+          def git_uncached
+            FileUtils.mkdir_p(self)
+            if File.exist?(subpath('.git'))
+              ::Git.open(self)
+            else
+              ::Git.init(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/base.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'eac_git/local'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/envs'
+require 'avm/launcher/paths/real'
+require 'avm/launcher/git/error'
+
+module Avm
+  module Launcher
+    module Git
+      class Base < ::Avm::Launcher::Paths::Real
+        require_sub __FILE__
+        enable_simple_cache
+        extend ::Avm::Launcher::Git::Base::ClassMethods
+        include ::Avm::Launcher::Git::Base::DirtyFiles
+        include ::Avm::Launcher::Git::Base::Remotes
+        include ::Avm::Launcher::Git::Base::Subrepo
+        include ::Avm::Launcher::Git::Base::Underlying
+
+        attr_reader :eac_git
+        delegate :descendant?, :merge_base, :rev_parse, to: :eac_git
+
+        def initialize(path)
+          super(path)
+
+          @eac_git = ::EacGit::Local.new(path)
+        end
+
+        def init_bare
+          FileUtils.mkdir_p(self)
+          ::EacRubyUtils::Envs.local.command('git', 'init', '--bare', self).execute! unless
+          File.exist?(subpath('.git'))
+        end
+
+        # @return [Pathname]
+        def root_path
+          @root_path ||= self.class.find_root(to_s)
+        end
+
+        def descendant?(descendant, ancestor)
+          base = merge_base(descendant, ancestor)
+          return false if base.blank?
+
+          revparse = execute!('rev-parse', '--verify', ancestor).strip
+          base == revparse
+        end
+
+        def subtree_split(prefix)
+          execute!('subtree', '-q', 'split', '-P', prefix).strip
+        end
+
+        def push(remote_name, refspecs, options = {})
+          refspecs = [refspecs] unless refspecs.is_a?(Array)
+          args = ['push']
+          args << '--dry-run' if options[:dryrun]
+          args << '--force' if options[:force]
+          system!(args + [remote_name] + refspecs)
+        end
+
+        def push_all(remote_name)
+          system!('push', '--all', remote_name)
+          system!('push', '--tags', remote_name)
+        end
+
+        def fetch(remote_name, options = {})
+          args = ['fetch', '-p', remote_name]
+          args += %w[--tags --prune-tags --force] if options[:tags]
+          execute!(*args)
+        end
+
+        def current_branch
+          execute!(%w[symbolic-ref -q HEAD]).gsub(%r{\Arefs/heads/}, '').strip
+        end
+
+        def reset_hard(ref)
+          execute!('reset', '--hard', ref)
+        end
+
+        def raise(message)
+          ::Kernel.raise Avm::Launcher::Git::Error.new(self, message)
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Git
+      class Error < StandardError
+        def initialize(git_instance, message)
+          super("#{message} (Repository: #{git_instance})")
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/mirror_update.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/git/base'
+
+module Avm
+  module Launcher
+    module Git
+      class MirrorUpdate < ::Avm::Launcher::Paths::Real
+        include ::EacRubyUtils::SimpleCache
+
+        def initialize(target_path, source_path, source_rev)
+          super(target_path)
+          @target_git = ::Avm::Launcher::Git::Base.new(self)
+          @source_git = ::Avm::Launcher::Git::Base.new(source_path)
+          @source_rev = source_rev
+          run
+        end
+
+        private
+
+        def run
+          fetch_remote_source
+          reset_source_rev
+        end
+
+        def fetch_remote_source
+          @target_git.git
+          @target_git.assert_remote_url('origin', @source_git)
+          @target_git.fetch('origin', tags: true)
+        end
+
+        def reset_source_rev
+          @target_git.reset_hard(@source_git.rev_parse(@source_rev, true))
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/publish_base.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/simple_cache'
+require 'avm/launcher/publish/base'
+require 'avm/launcher/publish/check_result'
+
+module Avm
+  module Launcher
+    module Git
+      class PublishBase < ::Avm::Launcher::Publish::Base
+        include ::EacRubyUtils::SimpleCache
+        enable_speaker
+
+        CHECKERS = %w[remote_url remote_fetch publish_remote_no_exist remote_equal remote_following
+                      local_following].freeze
+
+        REMOTE_UNAVAILABLE_MESSAGES = ['could not resolve host', 'connection timed out',
+                                       'no route to host'].map(&:downcase).freeze
+
+        protected
+
+        def internal_check
+          CHECKERS.each do |checker|
+            result = send("#{checker}_check_result")
+            return result if result
+          end
+          divergent_result_check_result
+        rescue ::Avm::Launcher::Instances::Error => e
+          ::Avm::Launcher::Publish::CheckResult.blocked(e.message)
+        rescue ::StandardError => e
+          raise e unless remote_unavailable_error?(e)
+
+          ::Avm::Launcher::Publish::CheckResult.blocked(e.message)
+        end
+
+        private
+
+        def remote_url_check_result
+          remote = sgit.remote(remote_name)
+          return if remote.exist? && remote.url.present?
+
+          ::Avm::Launcher::Publish::CheckResult.blocked("Remote \"#{remote_name}\" has blank path")
+        end
+
+        def remote_fetch_check_result
+          remote_fetch
+          nil
+        end
+
+        def remote_unavailable_error?(error)
+          error_message = error.message.downcase
+          REMOTE_UNAVAILABLE_MESSAGES.any? do |message|
+            error_message.include?(message)
+          end
+        end
+
+        def publish_remote_no_exist_check_result
+          return nil if sgit.remote_exist?(remote_name)
+
+          ::Avm::Launcher::Publish::CheckResult.blocked('Remote does not exist')
+        end
+
+        def remote_equal_check_result
+          return nil unless remote_sha.present? && remote_sha == local_sha
+
+          ::Avm::Launcher::Publish::CheckResult.updated('Remote equal')
+        end
+
+        def remote_following_check_result
+          return nil unless remote_sha.present? && sgit.descendant?(remote_sha, local_sha)
+
+          ::Avm::Launcher::Publish::CheckResult.outdated('Remote following')
+        end
+
+        def divergent_result_check_result
+          ::Avm::Launcher::Publish::CheckResult.blocked(
+            "Divergent (L: #{local_sha}, R: #{remote_sha})"
+          )
+        end
+
+        def local_following?
+          return true if remote_sha.blank?
+
+          sgit.descendant?(local_sha, remote_sha)
+        end
+
+        def local_following_check_result
+          return nil unless local_following?
+
+          ::Avm::Launcher::Publish::CheckResult.pending('Local following')
+        end
+
+        def sgit_uncached
+          ::Avm::Launcher::Git::Base.new(instance.warped)
+        end
+
+        def publish
+          info 'Pushing...'
+          sgit.push(remote_name, 'HEAD:master',
+                    dryrun: !::Avm::Launcher::Context.current.publish_options[:confirm])
+          info 'Pushed!'
+        end
+
+        def local_sha
+          sgit.git.object('HEAD').sha
+        end
+
+        def remote_sha_uncached
+          remote_fetch
+          b = sgit.git.branches["#{remote_name}/master"]
+          b ? b.gcommit.sha : nil
+        end
+
+        def remote_fetch_uncached
+          sgit.fetch(remote_name)
+        end
+
+        def remote_name
+          ::Avm::Launcher::Git::WarpBase::TARGET_REMOTE
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/remote.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    module Git
+      class Remote
+        common_constructor :git, :name
+
+        def exist?
+          git.execute!('remote').each_line.any? { |line| line.strip == name }
+        end
+
+        def ls
+          git.execute!(['ls-remote', name]).each_line.map do |line|
+            x = line.strip.split(/\s+/)
+            [x[1], x[0]]
+          end.to_h
+        end
+
+        # +git remote add ...+
+        def add(url)
+          git.execute!('remote', 'add', name, url)
+        end
+
+        # +git remote rm ...+
+        def remove
+          git.execute!('remote', 'rm', name)
+        end
+
+        # +git remote get-url ...+
+        def url
+          git.execute!('remote', 'get-url', name).strip.if_present(nil)
+        end
+
+        # git remote set-url ...
+        def url_set(url)
+          git.execute!('remote', 'set-url', name, url)
+        end
+
+        # Add or set URL if +url+ is present, remove remote if is blank.
+        def url=(url)
+          if exist? && url.blank?
+            remove
+          elsif exist? && self.url != url
+            url_set(url)
+          elsif !exist?
+            add(url)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/git/sub_warp_base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'avm/projects/stereotype'
+require 'avm/launcher/errors/base'
+
+module Avm
+  module Launcher
+    module Git
+      module SubWarpBase
+        private
+
+        def parent_instance_uncached
+          r = find_parent_instance(instance.parent)
+          return r if r
+
+          ::Avm::Launcher::Errors::Base.new('Git parent not found')
+        end
+
+        def find_parent_instance(current)
+          if ::Avm::Projects::Stereotype.git_stereotypes.any? { |s| current.stereotype?(s) }
+            return current
+          end
+
+          current.parent ? find_parent_instance(current.parent) : nil
+        end
+
+        def to_parent_git_path
+          instance.logical.gsub(%r{\A#{Regexp.quote(parent_instance.logical)}/}, '')
+        end
+      end
+    end
+  end
+end