GitLab に push すると LFS のエラーが発生する場合の回避策

$ git clone git@gitlab.com:ApexAI/performance_test.git
$ cd performance_test
$ git remote set-url origin git@gitlab.example.com:myuser/performance_test.git
$ git push --all origin

remote: Resolving deltas: 100% (1106/1106), done.
remote: GitLab: LFS objects are missing. Ensure LFS is properly set up or try a manual "git lfs push --all".
To gitlab.example.com:myuser/peformance_test.git
 ! [remote rejected] master -> master (pre-receive hook declined)
error: failed to push some refs to 'git@gitlab.example.com:myuser/peformance_test.git'

$ sudo gitlab-rails console
> Feature.disable(:lfs_check)

$ git lfs push --all origin

  (missing) performance_test/bin/fastrtpsgen.jar (189fa3ed5db458d4de938e94b1488e1bb60bdcdd76d1185e722c23d3d1860e92)
hint: Your push was rejected due to missing or corrupt local objects.
hint: You can disable this check with: 'git config lfs.allowincompletepush true'
Uploading LFS objects:   0% (0/1), 0 B | 0 B/s, done.

$ git config lfs.allowincompletepush true
$ git lfs push --all origin

LFS upload missing objects: (0/1), 0 B | 0 B/s
  (missing) performance_test/bin/fastrtpsgen.jar (189fa3ed5db458d4de938e94b1488e1bb60bdcdd76d1185e722c23d3d1860e92)
Uploading LFS objects:   0% (0/1), 0 B | 0 B/s, done.

$ git push --all origin

    class LfsCheck < BaseChecker
      LOG_MESSAGE = 'Scanning repository for blobs stored in LFS and verifying their files have been uploaded to GitLab...'
      ERROR_MESSAGE = 'LFS objects are missing. Ensure LFS is properly set up or try a manual "git lfs push --all".'

      def validate!
        return unless Feature.enabled?(:lfs_check, default_enabled: true)
        return unless project.lfs_enabled?
        return if skip_lfs_integrity_check

        logger.log_timed(LOG_MESSAGE) do
          lfs_check = Checks::LfsIntegrity.new(project, newrev, logger.time_left)

          if lfs_check.objects_missing?
            raise GitAccess::ForbiddenError, ERROR_MESSAGE
          end
        end
      end
    end

$ sudo gitlab-rails console
> Feature.disable(:lfs_check)

$ git push --all origin

    class LfsIntegrity
      def initialize(project, newrev, time_left)
        @project = project
        @newrev = newrev
        @time_left = time_left
      end

      def objects_missing?
        return false unless @newrev && @project.lfs_enabled?

        new_lfs_pointers = Gitlab::Git::LfsChanges.new(@project.repository, @newrev)
                                                  .new_pointers(object_limit: ::Gitlab::Git::Repository::REV_LIST_COMMIT_LIMIT, dynamic_timeout: @time_left)

        return false unless new_lfs_pointers.present?

        existing_count = @project.all_lfs_objects
                                 .for_oids(new_lfs_pointers.map(&:lfs_oid))
                                 .count

        existing_count != new_lfs_pointers.count
      end
    end

    class LfsChanges
      def initialize(repository, newrev = nil)
        @repository = repository
        @newrev = newrev
      end

      def new_pointers(object_limit: nil, not_in: nil, dynamic_timeout: nil)
        @repository.gitaly_blob_client.get_new_lfs_pointers(@newrev, object_limit, not_in, dynamic_timeout)
      end

      def all_pointers
        @repository.gitaly_blob_client.get_all_lfs_pointers
      end
    end

      def get_new_lfs_pointers(revision, limit, not_in, dynamic_timeout = nil)
        request = Gitaly::GetNewLFSPointersRequest.new(
          repository: @gitaly_repo,
          revision: encode_binary(revision),
          limit: limit || 0
        )

        if not_in.nil? || not_in == :all
          request.not_in_all = true
        else
          request.not_in_refs += not_in
        end

        timeout =
          if dynamic_timeout
            [dynamic_timeout, GitalyClient.medium_timeout].min
          else
            GitalyClient.medium_timeout
          end

        response = GitalyClient.call(
          @gitaly_repo.storage_name,
          :blob_service,
          :get_new_lfs_pointers,
          request,
          timeout: timeout
        )

        map_lfs_pointers(response)
      end

    def get_new_lfs_pointers(request, call)
      Enumerator.new do |y|
        changes = lfs_changes(request, call)
        object_limit = request.limit.zero? ? nil : request.limit
        not_in = request.not_in_all ? :all : request.not_in_refs.to_a
        blobs = changes.new_pointers(object_limit: object_limit, not_in: not_in)

        sliced_gitaly_lfs_pointers(blobs) do |lfs_pointers|
          y.yield Gitaly::GetNewLFSPointersResponse.new(lfs_pointers: lfs_pointers)
        end
      end
    end

    # 省略

    private

    def lfs_changes(request, call)
      repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)

      Gitlab::Git::LfsChanges.new(repo, request.revision)
    end

      def git_new_pointers(object_limit, not_in)
        rev_list.new_objects(rev_list_params(not_in: not_in)) do |object_ids|
          object_ids = object_ids.take(object_limit) if object_limit

          Gitlab::Git::Blob.batch_lfs_pointers(@repository, object_ids)
        end
      end

        # Find LFS blobs given an array of sha ids
        # Returns array of Gitlab::Git::Blob
        # Does not guarantee blob data will be set
        def batch_lfs_pointers(repository, blob_ids)
          blob_ids.lazy
                  .select { |sha| possible_lfs_blob?(repository, sha) }
                  .map { |sha| rugged_raw(repository, sha, limit: LFS_POINTER_MAX_SIZE) }
                  .select(&:lfs_pointer?)
                  .force
        end

      # 省略

      # Valid LFS object pointer is a text file consisting of
      # version
      # oid
      # size
      # see https://github.com/github/git-lfs/blob/v1.1.0/docs/spec.md#the-pointer
      def lfs_pointer?
        self.class.size_could_be_lfs?(size) && has_lfs_version_key? && lfs_oid.present? && lfs_size.present?
      end

      def lfs_oid
        if has_lfs_version_key?
          oid = data.match(/(?<=sha256:)([0-9a-f]{64})/)
          return oid[1] if oid
        end

        nil
      end

      def lfs_size
        if has_lfs_version_key?
          size = data.match(/(?<=size )([0-9]+)/)
          return size[1].to_i if size
        end

        nil
      end

      # 省略

      private

      def has_lfs_version_key?
        !empty? && text? && data.start_with?("version https://git-lfs.github.com/spec")
      end

version https://git-lfs.github.com/spec/v1
oid sha256:44a8486abdf0330a3fe6b586e407506e738fe075fe0b5dfc43961e358fda7206
size 2684586

#!/bin/sh
git rev-list --all --filter=blob:limit=200 --in-commit-order --objects \
| while read object path ; do
    type=`git cat-file -t $object`
    if [ "$type" = "blob" ]; then
      if git cat-file -p $object | grep -q -e "^version https://git-lfs.github.com/spec" ; then
        echo "*********** LFS pointer is found *********"
        echo "Blob: $object, Path: $path"
        echo "*********** Start content *********"
        git cat-file -p $object
        echo "*********** End content *********"
      fi
    fi
done

$ get-all-lfs-pointers.sh

*********** LFS pointer is found *********
Blob: 987f780ba6c01f746b83b4f5718fe0e6f70a0e7d, Path: performance_test/bin/fastrtpsgen.jar
*********** Start content *********
version https://git-lfs.github.com/spec/v1
oid sha256:189fa3ed5db458d4de938e94b1488e1bb60bdcdd76d1185e722c23d3d1860e92
size 2353057
*********** End content *********

#!/bin/sh
obj_name="$1"
shift
git log "$@" --pretty=format:'%T %h %s' \
| while read tree commit subject ; do
    if git ls-tree -r $tree | grep -q "$obj_name" ; then
        echo $commit "$subject"
    fi
done

$ find-commit-from-blob.sh 987f780ba6c01f746b83b4f5718fe0e6f70a0e7d

008c746 Adding the code.

$ git checkout 008c746