dapp 0.10.2 → 0.36.24

data/lib/dapp/dimg/git_artifact.rb

@@ -2,252 +2,268 @@ module Dapp
   module Dimg
     # Git repo artifact
     class GitArtifact
+      include Helper::Tar
+      include Helper::Trivia
+
       attr_reader :repo
       attr_reader :name
+      attr_reader :as
+
+      # FIXME: переименовать cwd в from
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(repo, to:, name: nil, branch: nil, commit: nil,
-                     cwd: nil, include_paths: nil, exclude_paths: nil, owner: nil, group: nil,
-                     stages_dependencies: {})
+      def initialize(repo, dimg, to:, name: nil, branch: nil, tag: nil, commit: nil,
+                     cwd: nil, include_paths: nil, exclude_paths: nil, owner: nil, group: nil, as: nil,
+                     stages_dependencies: {}, ignore_signature_auto_calculation: false)
         @repo = repo
+        @dimg = dimg
         @name = name
 
-        @branch = branch || repo.dimg.dapp.cli_options[:git_artifact_branch] || repo.branch
+        @ignore_signature_auto_calculation = ignore_signature_auto_calculation
+
+        @branch = branch
+        @tag = tag
         @commit = commit
 
         @to = to
-        @cwd = begin
-          if cwd.nil? || cwd.empty?
-            ''
-          else
-            cwd = File.expand_path(File.join('/', cwd))[1..-1] # must be relative
-            "#{cwd.chomp('/')}/"
-          end
-        end
+        @cwd = (cwd.nil? || cwd.empty? || cwd == '/') ? '' : File.expand_path(File.join('/', cwd, '/'))[1..-1]
         @include_paths = include_paths
         @exclude_paths = exclude_paths
         @owner = owner
         @group = group
-
+        @as = as
         @stages_dependencies = stages_dependencies
       end
       # rubocop:enable Metrics/ParameterLists
 
       def apply_archive_command(stage)
-        credentials = [:owner, :group].map { |attr| "--#{attr}=#{send(attr)}" unless send(attr).nil? }.compact
+        res = repo.dapp.ruby2go_git_artifact(
+          "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
+          "method" => "ApplyArchiveCommand",
+          "Stage" => JSON.dump(merge_layer_commit_stub_stage_state(stage.get_ruby2go_state_hash, stage)),
+        )
 
-        [].tap do |commands|
-          commands << "#{repo.dimg.dapp.install_bin} #{credentials.join(' ')} -d #{to}"
-          if any_changes?(nil, stage.layer_commit(self))
-            commands << "#{sudo}#{repo.dimg.dapp.tar_bin} -xf #{archive_file(stage.layer_commit(self))} -C #{to}"
-          end
-        end
-      end
+        raise res["error"] if res["error"]
 
-      def apply_patch_command(stage)
-        patch_command(stage.prev_g_a_stage.layer_commit(self), stage.layer_commit(self))
-      end
+        self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
+        stage.set_ruby2go_state_hash(JSON.load(res["data"]["Stage"]))
 
-      def apply_dev_patch_command(stage)
-        patch_command(stage.prev_g_a_stage.layer_commit(self), nil)
+        Array(res["data"]["result"])
       end
 
-      def stage_dependencies_checksums(stage, from_commit = nil, to_commit = latest_commit)
-        return [] if (stage_dependencies = stages_dependencies[stage.name]).empty?
+      def merge_layer_commit_stub_stage_state(stage_state, stage)
+        # Data for StubStage specific for ApplyPatchCommand
+        stage_state["LayerCommitMap"] = {
+          paramshash => stage.layer_commit(self),
+        }
+        stage_state["PrevStage"]["LayerCommitMap" ] = {
+          paramshash => stage.prev_stage.layer_commit(self),
+        }
 
-        paths = include_paths(true) + base_paths(stage_dependencies, true)
-        diff_patches(from_commit, to_commit, paths: paths).map do |patch|
-          delta_new_file = patch.delta.new_file
-          content = patch.hunks.map { |h| h.lines.select { |l| l.line_origin == :context }.map(&:content).join }.join
-          Digest::SHA256.hexdigest [delta_new_file[:path], content].join(':::')
-        end
+        stage_state
       end
 
-      def patch_size(from, to)
-        diff_patches(from, to).reduce(0) do |bytes, patch|
-          patch.hunks.each do |hunk|
-            hunk.lines.each do |l|
-              bytes +=
-                case l.line_origin
-                when :eof_newline_added, :eof_newline_removed then 1
-                when :addition, :deletion, :binary            then l.content.size
-                else # :context, :file_header, :hunk_header, :eof_no_newline
-                  0
-                end
-            end
-          end
-          bytes
-        end
-      end
+      def apply_patch_command(stage)
+        res = repo.dapp.ruby2go_git_artifact(
+          "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
+          "method" => "ApplyPatchCommand",
+          "Stage" => JSON.dump(merge_layer_commit_stub_stage_state(stage.get_ruby2go_state_hash, stage)),
+        )
 
-      def dev_patch_hash(stage)
-        Digest::SHA256.hexdigest diff_patches(stage.prev_g_a_stage.layer_commit(self), nil).map(&:to_s).join(':::')
-      end
+        raise res["error"] if res["error"]
 
-      def latest_commit
-        @latest_commit ||= commit || repo.latest_commit(branch)
-      end
+        self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
+        stage.set_ruby2go_state_hash(JSON.load(res["data"]["Stage"]))
 
-      def paramshash
-        Digest::SHA256.hexdigest [full_name, to, cwd, *include_paths, *exclude_paths, owner, group].map(&:to_s).join(':::')
+        Array(res["data"]["result"])
       end
 
-      def full_name
-        "#{repo.name}#{name ? "_#{name}" : nil}"
+      def calculate_stage_dependencies_checksum(stage)
+        res = repo.dapp.ruby2go_git_artifact(
+          "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
+          "method" => "StageDependenciesChecksum",
+          "StageName" => ::Dapp::Helper::CaseConversion.snake_case_to_lower_camel_case(stage.name.to_s),
+        )
+
+        raise res["error"] if res["error"]
+
+        self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
+
+        result = res["data"]["result"]
+        return [] if result == ""
+        return result
       end
 
-      def any_changes?(from, to = latest_commit)
-        diff_patches(from, to).any?
+      def stage_dependencies_checksum(stage)
+        stage_dependencies_key = [stage.name, commit]
+        @stage_dependencies_checksums ||= {}
+        @stage_dependencies_checksums[stage_dependencies_key] ||= calculate_stage_dependencies_checksum(stage)
       end
 
-      protected
+      def patch_size(from_commit)
+        res = repo.dapp.ruby2go_git_artifact(
+          "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
+          "method" => "PatchSize",
+          "FromCommit" => from_commit,
+        )
 
-      attr_reader :to
-      attr_reader :commit
-      attr_reader :branch
-      attr_reader :cwd
-      attr_reader :owner
-      attr_reader :group
-      attr_reader :stages_dependencies
+        raise res["error"] if res["error"]
 
-      def patch_command(prev_commit, current_commit)
-        [].tap do |commands|
-          if any_changes?(prev_commit, current_commit)
-            commands << "#{sudo}#{repo.dimg.dapp.git_bin} apply --whitespace=nowarn --directory=#{to} --unsafe-paths " \
-                        "#{patch_file(prev_commit, current_commit)}"
-          end
-        end
-      end
+        self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
 
-      def sudo
-        repo.dimg.dapp.sudo_command(owner: owner, group: group)
+        res["data"]["result"]
       end
 
-      def archive_file(to_commit)
-        create_file(repo.dimg.tmp_path('archives', archive_file_name(to_commit))) do |f|
-          Gem::Package::TarWriter.new(f) do |tar|
-            diff_patches(nil, to_commit).each do |patch|
-              entry = patch.delta.new_file
-              tar.add_file slice_cwd(entry[:path]), entry[:mode] do |tf|
-                tf.write repo.lookup_object(entry[:oid]).content
-              end
-            end
+      def get_ruby2go_state_hash
+        {
+          "Name" => @name.to_s,
+          "As" => @as.to_s,
+          "Branch" => @branch.to_s,
+          "Tag" => @tag.to_s,
+          "Commit" => @commit.to_s,
+          "To" => @to.to_s,
+          "Cwd" => @cwd.to_s,
+          "RepoPath" => File.join("/", @cwd.to_s),
+          "Owner" => @owner.to_s,
+          "Group" => @group.to_s,
+          "IncludePaths" => @include_paths,
+          "ExcludePaths" => @exclude_paths,
+          "StagesDependencies" => @stages_dependencies.map {|k, v| [_stages_map[k], Array(v).map(&:to_s)]}.to_h,
+          "PatchesDir" => dimg.tmp_path('patches'),
+          "ContainerPatchesDir" => dimg.container_tmp_path('patches'),
+          "ArchivesDir" => dimg.tmp_path('archives'),
+          "ContainerArchivesDir" => dimg.container_tmp_path('archives'),
+        }.tap {|res|
+          if repo.is_a? ::Dapp::Dimg::GitRepo::Local
+            res["LocalGitRepo"] = repo.get_ruby2go_state_hash
+          elsif repo.is_a? ::Dapp::Dimg::GitRepo::Remote
+            res["RemoteGitRepo"] = repo.get_ruby2go_state_hash
+          else
+            raise
           end
-        end
-        repo.dimg.container_tmp_path('archives', archive_file_name(to_commit))
-      rescue Gem::Package::TooLongFileName => e
-        raise Error::TarWriter, message: e.message
+        }
       end
 
-      def slice_cwd(path)
-        return path if cwd.empty?
-        path
-          .reverse
-          .chomp(cwd.reverse)
-          .reverse
+      def _stages_map
+        {
+          before_install: "beforeInstall",
+          install: "install",
+          before_setup: "beforeSetup",
+          setup: "setup",
+          build_artifact: "buildArtifact",
+        }
       end
 
-      def archive_file_name(commit)
-        file_name(commit, 'tar')
+      def _stages_map_reversed
+        _stages_map.map {|k, v| [v, k]}.to_h
       end
 
-      def patch_file(from, to)
-        create_file(repo.dimg.tmp_path('patches', patch_file_name(from, to))) do |f|
-          diff_patches(from, to).each { |patch| f.write change_patch_new_file_path(patch) }
-        end
-        repo.dimg.container_tmp_path('patches', patch_file_name(from, to))
-      end
-
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def change_patch_new_file_path(patch)
-        patch.to_s.lines.tap do |lines|
-          modify_patch_line = proc do |line_number, path_char|
-            action_part, path_part = lines[line_number].split
-            if (path_with_cwd = path_part.partition("#{path_char}/").last).start_with?(cwd)
-              path_with_cwd.sub(cwd, '').tap do |native_path|
-                expected_path = File.join(path_char, native_path)
-                lines[line_number] = [action_part, expected_path].join(' ') + "\n"
-              end
-            end
-          end
-
-          modify_patch = proc do |*modify_patch_line_args|
-            native_paths = modify_patch_line_args.map { |args| modify_patch_line.call(*args) }
-            unless (native_paths = native_paths.compact.uniq).empty?
-              raise Error::Build, code: :unsupported_patch_format, data: { patch: patch.to_s } unless native_paths.one?
-              native_path = native_paths.first
-              lines[0] = ['diff --git', File.join('a', native_path), File.join('b', native_path)].join(' ') + "\n"
-            end
+      def set_ruby2go_state_hash(new_state)
+        [
+          [:@name, new_state["Name"]],
+          [:@as, new_state["As"]],
+          [:@branch, new_state["Branch"]],
+          [:@tag, new_state["Tag"]],
+          [:@commit, new_state["Commit"]],
+          [:@cwd, new_state["Cwd"]],
+          [:@owner, new_state["Owner"]],
+          [:@group, new_state["Group"]],
+        ].each do |var, new_value|
+          if new_value != ""
+            instance_variable_set(var, new_value)
           end
+        end
 
-          case
-          when patch.delta.deleted? then modify_patch.call([3, 'a'])
-          when patch.delta.added? then modify_patch.call([4, 'b'])
-          when patch.delta.modified?
-            if patch_file_mode_changed?(patch)
-              modify_patch.call([4, 'a'], [5, 'b'])
-            else
-              modify_patch.call([2, 'a'], [3, 'b'])
-            end
-          else
-            raise
-          end
-        end.join
+        @stages_dependencies = new_state["StagesDependencies"].map do |k, v|
+          [_stages_map_reversed[k], v]
+        end.to_h
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def patch_file_mode_changed?(patch)
-        patch.delta.old_file[:mode] != patch.delta.new_file[:mode]
-      end
+      def latest_commit
+        @latest_commit ||= begin
+          res = repo.dapp.ruby2go_git_artifact("GitArtifact" => JSON.dump(get_ruby2go_state_hash), "method" => "LatestCommit")
 
-      def patch_file_name(from, to)
-        file_name(from, to, 'patch')
-      end
+          raise res["error"] if res["error"]
 
-      def file_name(*args, ext)
-        "#{[full_name, args].flatten.join('_')}.#{ext}"
-      end
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
 
-      def create_file(file_path, &blk)
-        File.open(file_path, File::RDWR | File::CREAT, &blk)
+          res["data"]["result"]
+        end.tap do |c|
+          repo.dapp.log_info("Repository `#{repo.name}`: latest commit `#{c}` to `#{to}`") unless ignore_signature_auto_calculation
+        end
       end
 
-      def diff_patches(from, to, paths: include_paths_or_cwd)
-        (@diff_patches ||= {})[[from, to, paths]] = repo.patches(from, to,
-                                                                 paths: paths,
-                                                                 exclude_paths: exclude_paths(true),
-                                                                 force_text: true)
-      end
+      def paramshash
+        @paramshash ||= begin
+          res = repo.dapp.ruby2go_git_artifact("GitArtifact" => JSON.dump(get_ruby2go_state_hash), "method" => "GetParamshash")
+
+          raise res["error"] if res["error"]
 
-      def include_paths_or_cwd
-        case
-        when !include_paths(true).empty? then include_paths(true)
-        when !cwd.empty? then [cwd]
-        else
-          []
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
+
+          res["data"]["result"]
         end
       end
 
-      def exclude_paths(with_cwd = false)
-        repo.exclude_paths + base_paths(@exclude_paths, with_cwd)
+      def full_name
+        @full_name ||= begin
+          res = repo.dapp.ruby2go_git_artifact("GitArtifact" => JSON.dump(get_ruby2go_state_hash), "method" => "FullName")
+
+          raise res["error"] if res["error"]
+
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
+
+          res["data"]["result"]
+        end
       end
 
-      def include_paths(with_cwd = false)
-        base_paths(@include_paths, with_cwd)
+      def is_patch_empty(stage)
+        return @is_patch_empty if !@is_patch_empty.nil?
+
+        @is_patch_empty = begin
+          res = repo.dapp.ruby2go_git_artifact(
+            "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
+            "method" => "IsPatchEmpty",
+            "Stage" => JSON.dump(merge_layer_commit_stub_stage_state({"PrevStage" => {}}, stage)),
+          )
+
+          raise res["error"] if res["error"]
+
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
+
+          res["data"]["result"]
+        end
       end
 
-      def base_paths(paths, with_cwd = false)
-        [paths].flatten.compact.map do |path|
-          if with_cwd && !cwd.empty?
-            File.join(cwd, path)
-          else
-            path
-          end
-            .chomp('/')
-            .reverse.chomp('/')
-            .reverse
+      def is_empty
+        return @is_empty if !@is_empty.nil?
+
+        @is_empty = begin
+          res = repo.dapp.ruby2go_git_artifact(
+            "GitArtifact" => JSON.dump(get_ruby2go_state_hash),
+            "method" => "IsEmpty",
+          )
+
+          raise res["error"] if res["error"]
+
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["GitArtifact"]))
+
+          res["data"]["result"]
         end
       end
+
+      protected
+
+      attr_reader :dimg
+      attr_reader :to
+      attr_reader :commit
+      attr_reader :branch
+      attr_reader :tag
+      attr_reader :cwd
+      attr_reader :owner
+      attr_reader :group
+      attr_reader :stages_dependencies
+      attr_reader :ignore_signature_auto_calculation
     end
   end
 end

data/lib/dapp/dimg/git_repo/base.rb

@@ -3,11 +3,13 @@ module Dapp
     module GitRepo
       # Base class for any Git repo (remote, gitkeeper, etc)
       class Base
-        attr_reader :dimg
+        include Helper::Trivia
+
         attr_reader :name
+        attr_reader :dapp
 
-        def initialize(dimg, name)
-          @dimg = dimg
+        def initialize(dapp, name)
+          @dapp = dapp
           @name = name
         end
 
@@ -15,51 +17,61 @@ module Dapp
           []
         end
 
-        def patches(from, to, exclude_paths: [], **kwargs)
-          diff(from, to, **kwargs).patches.select do |patch|
-            !exclude_paths.any? { |p| check_path?(patch.delta.new_file[:path], p) }
-          end
+        def get_ruby2go_state_hash
+          {
+            "Name" => @name.to_s,
+          }
         end
 
-        def diff(from, to, **kwargs)
-          if from.nil?
-            Rugged::Tree.diff(git, nil, to, **kwargs)
-          else
-            lookup_commit(from).diff(lookup_commit(to), **kwargs)
-          end
+        def set_ruby2go_state_hash(state)
+          @name = state["Name"]
         end
 
-        def commit_exists?(commit)
-          git.exists?(commit)
+        def empty?
+          return @empty if !@empty.nil?
+          @empty = ruby2go_method("IsEmpty")
+          @empty
         end
 
-        def latest_commit(_branch)
-          raise
+        def find_commit_id_by_message(regex)
+          ruby2go_method("FindCommitIdByMessage", "regex" => regex)
         end
 
-        def branch
-          git.head.name.sub(/^refs\/heads\//, '')
-        rescue Rugged::ReferenceError => e
-          raise Error::Rugged, code: :git_repository_reference_error, data: { name: name, message: e.message.downcase }
+        def commit_exists?(commit)
+          ruby2go_method("IsCommitExists", "commit" => commit)
         end
 
-        def commit_at(commit)
-          lookup_commit(commit).time.to_i
-        end
+        def remote_origin_url
+          return @remote_origin_url if @remote_origin_url_set
 
-        def find_commit_id_by_message(regex)
-          walker.each do |commit|
-            next unless commit.message =~ regex
-            return commit.oid
+          res = ruby2go_method("RemoteOriginUrl")
+          if res != ""
+            @remote_origin_url = res
           end
+          @remote_origin_url_set = true
+
+          @remote_origin_url
         end
 
-        def walker
-          walker = Rugged::Walker.new(git)
-          walker.push(git.head.target_id)
-          walker
+        def latest_branch_commit(branch)
+          ruby2go_method("LatestBranchCommit", "branch" => branch)
         end
 
+        def head_commit
+          return @head_commit if !@head_commit.nil?
+          @head_commit = ruby2go_method("HeadCommit")
+          @head_commit
+        end
+
+        def head_branch_name
+          return @branch if !@branch.nil?
+          @branch = ruby2go_method("HeadBranchName")
+          @branch
+        end
+
+        # TODO Below operations does not affect build process, only used in sample.
+        # TODO Should be ported to golang without git_repo.GitRepo interface.
+
         def lookup_object(oid)
           git.lookup(oid)
         end
@@ -70,22 +82,14 @@ module Dapp
 
         protected
 
-        def git(**kwargs)
-          @git ||= Rugged::Repository.new(path, **kwargs)
+        def ruby2go_method(method, args_hash={})
+          raise
         end
 
-        private
-
-        def check_path?(path, format)
-          path_parts = path.split('/')
-          checking_path = nil
-
-          until path_parts.empty?
-            checking_path = [checking_path, path_parts.shift].compact.join('/')
-            return true if File.fnmatch(format, checking_path)
-          end
-          false
+        def git(**kwargs) # TODO remove
+          @git ||= Rugged::Repository.new(path.to_s, **kwargs)
         end
+
       end
     end
   end

data/lib/dapp/dimg/git_repo/local.rb

@@ -0,0 +1,45 @@
+module Dapp
+  module Dimg
+    module GitRepo
+      class Local < Base
+        attr_reader :path
+
+        def initialize(dapp, name, path)
+          super(dapp, name)
+          self.path = path
+        end
+
+        def get_ruby2go_state_hash
+          super.tap {|res|
+            p = @path.to_s
+            p = File.dirname(@path) if File.basename(@path) == ".git"
+            res["Path"] = p
+            res["GitDir"] = @path.to_s
+          }
+        end
+
+        def ruby2go_method(method, args_hash={})
+          res = dapp.ruby2go_git_repo(args_hash.merge("LocalGitRepo" => JSON.dump(get_ruby2go_state_hash), "method" => method))
+
+          raise res["error"] if res["error"]
+
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["LocalGitRepo"]))
+
+          res["data"]["result"]
+        end
+
+        def path=(path) # TODO remove
+          @path ||= Pathname(Rugged::Repository.new(path).path)
+        rescue Rugged::RepositoryError, Rugged::OSError => _e
+          raise Error::Rugged, code: :local_git_repository_does_not_exist, data: { path: path }
+        end
+
+        def lookup_commit(commit)
+          super
+        rescue Rugged::OdbError, TypeError => _e
+          raise Error::Rugged, code: :commit_not_found_in_local_git_repository, data: { commit: commit, path: path }
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/git_repo/own.rb

@@ -1,37 +1,9 @@
 module Dapp
   module Dimg
     module GitRepo
-      class Own < Base
-        def initialize(dimg)
-          super(dimg, 'own')
-        end
-
-        def exclude_paths
-          dimg.dapp.local_git_artifact_exclude_paths
-        end
-
-        def path
-          @path ||= Rugged::Repository.discover(dimg.home_path.to_s).path
-        rescue Rugged::RepositoryError => _e
-          raise Error::Rugged, code: :local_git_repository_does_not_exist
-        end
-
-        def diff(from, to, **kwargs)
-          if to.nil?
-            git.lookup(from).diff_workdir(**kwargs)
-          else
-            super
-          end
-        end
-
-        def latest_commit(_branch = nil)
-          git.head.target_id
-        end
-
-        def lookup_commit(commit)
-          super
-        rescue Rugged::OdbError, TypeError => _e
-          raise Error::Rugged, code: :commit_not_found_in_local_git_repository, data: { commit: commit }
+      class Own < Local
+        def initialize(dapp)
+          super(dapp, 'own', dapp.path.to_s)
         end
       end
     end