fix(git): Revert "feat(git): use git fetching for forkMode" (renovatebot#36045)

Author: rarkins

lib/modules/platform/github/index.spec.ts

@@ -648,6 +648,7 @@ describe('modules/platform/github/index', () => {
     it('should update fork when using forkToken and forkOrg', async () => {
       const scope = httpMock.scope(githubApiHost);
       forkInitRepoMock(scope, 'some/repo', true);
+      scope.patch('/repos/forked/repo/git/refs/heads/master').reply(200);
       const config = await github.initRepo({
         repository: 'some/repo',
         forkToken: 'true',
@@ -665,6 +666,7 @@ describe('modules/platform/github/index', () => {
       });
       scope.post('/repos/forked/repo/git/refs').reply(200);
       scope.patch('/repos/forked/repo').reply(200);
+      scope.patch('/repos/forked/repo/git/refs/heads/master').reply(200);
       const config = await github.initRepo({
         repository: 'some/repo',
         forkToken: 'true',

lib/modules/platform/github/index.ts

@@ -42,7 +42,7 @@ import type { HttpResponse } from '../../../util/http/types';
 import { coerceObject } from '../../../util/object';
 import { regEx } from '../../../util/regex';
 import { sanitize } from '../../../util/sanitize';
-import { fromBase64, looseEquals } from '../../../util/string';
+import { coerceString, fromBase64, looseEquals } from '../../../util/string';
 import { ensureTrailingSlash } from '../../../util/url';
 import { incLimitedValue } from '../../../workers/global/limits';
 import type {
@@ -680,6 +680,31 @@ export async function initRepo({
           logger.warn({ err }, 'Could not set default branch');
         } /* v8 ignore stop */
       }
+      // This is a lovely "hack" by GitHub that lets us force update our fork's default branch
+      // with the base commit from the parent repository
+      const url = `repos/${config.repository}/git/refs/heads/${config.defaultBranch}`;
+      const sha = repo.defaultBranchRef.target.oid;
+      try {
+        logger.debug(
+          `Updating forked repository default sha ${sha} to match upstream`,
+        );
+        await githubApi.patchJson(url, {
+          body: {
+            sha,
+            force: true,
+          },
+          token: coerceString(forkToken, opts.token),
+        });
+      } catch (err) /* v8 ignore start */ {
+        logger.warn(
+          { url, sha, err: err.err ?? err },
+          'Error updating fork from upstream - cannot continue',
+        );
+        if (err instanceof ExternalHostError) {
+          throw err;
+        }
+        throw new ExternalHostError(err);
+      } /* v8 ignore stop */
     } else if (forkCreation) {
       logger.debug('Forked repo is not found - attempting to create it');
       forkedRepo = await createFork(forkToken, repository, forkOrg);
@@ -708,15 +733,9 @@ export async function initRepo({
   );
   parsedEndpoint.pathname = `${config.repository}.git`;
   const url = URL.format(parsedEndpoint);
-  let upstreamUrl = undefined;
-  if (forkCreation && config.parentRepo) {
-    parsedEndpoint.pathname = config.parentRepo + '.git';
-    upstreamUrl = URL.format(parsedEndpoint);
-  }
   await git.initRepo({
     ...config,
     url,
-    upstreamUrl,
   });
   const repoConfig: RepoResult = {
     defaultBranch: config.defaultBranch,

lib/util/git/index.spec.ts

@@ -1226,60 +1226,5 @@ describe('util/git/index', { timeout: 10000 }, () => {
       ).trim();
       expect(branch).toBe('develop');
     });
-
-    it('should fetch from upstream and update local branch', async () => {
-      const newBase = await tmp.dir({ unsafeCleanup: true });
-      const upstream = Git(newBase.path);
-      await upstream.init();
-      defaultBranch = (await upstream.raw('branch', '--show-current')).trim();
-      await upstream.addConfig('user.email', 'other@example.com');
-      await upstream.addConfig('user.name', 'Other');
-      await fs.writeFile(newBase.path + '/past_file', 'past');
-      await upstream.addConfig('commit.gpgsign', 'false');
-      await upstream.add(['past_file']);
-      await upstream.commit('past message');
-      await upstream.raw(['checkout', '-B', defaultBranch]);
-
-      const upstreamOrigin = await tmp.dir({ unsafeCleanup: true });
-      const upstreamRepo = Git(upstreamOrigin.path);
-      await upstreamRepo.clone(newBase.path, '.', ['--bare']);
-      await upstreamRepo.addConfig('commit.gpgsign', 'false');
-
-      tmpDir = await tmp.dir({ unsafeCleanup: true });
-      GlobalConfig.set({ localDir: tmpDir.path });
-
-      await git.initRepo({
-        url: origin.path,
-        defaultBranch,
-        upstreamUrl: upstreamOrigin.path,
-      });
-
-      await git.syncGit();
-      const tmpGit = Git(tmpDir.path);
-
-      // make sure origin exists ie. fork repo is cloned
-      const originRemote = (
-        await tmpGit.raw(['remote', 'get-url', 'origin'])
-      ).trim();
-      expect(originRemote.trim()).toBe(origin.path);
-
-      // make sure upstream exists
-      const upstreamRemote = (
-        await tmpGit.raw(['remote', 'get-url', 'upstream'])
-      ).trim();
-      expect(upstreamRemote).toBe(upstreamOrigin.path);
-
-      // verify fetch from upstream happened
-      // by checking the `upstream/main` branch in the forked repo's remote branches
-      const branches = await tmpGit.branch(['-r']);
-      expect(branches.all).toContain(`upstream/${defaultBranch}`);
-
-      // verify that the HEAD's match
-      const headSha = (await tmpGit.revparse(['HEAD'])).trim();
-      const upstreamSha = (
-        await tmpGit.revparse([`upstream/${defaultBranch}`])
-      ).trim();
-      expect(headSha).toBe(upstreamSha);
-    });
   });
 });

lib/util/git/index.ts

@@ -194,11 +194,9 @@ export async function validateGitVersion(): Promise<boolean> {
   return true;
 }
 
-async function fetchBranchCommits(preferUpstream = true): Promise<void> {
+async function fetchBranchCommits(): Promise<void> {
   config.branchCommits = {};
-  const url =
-    preferUpstream && config.upstreamUrl ? config.upstreamUrl : config.url;
-  const opts = ['ls-remote', '--heads', url];
+  const opts = ['ls-remote', '--heads', config.url];
   if (config.extraCloneOpts) {
     Object.entries(config.extraCloneOpts).forEach((e) =>
       // TODO: types (#22198)
@@ -496,25 +494,6 @@ export async function syncGit(): Promise<void> {
     (await getDefaultBranch(git));
   /* v8 ignore next -- TODO: add test */
   delete getCache()?.semanticCommits;
-
-  if (config.upstreamUrl) {
-    logger.debug(`Resetting ${config.currentBranch} to upstream`);
-    await git.addRemote('upstream', config.upstreamUrl);
-    await git.fetch(['upstream']);
-    await resetToBranch(config.currentBranch);
-    const resetLog = await git.reset([
-      '--hard',
-      `upstream/${config.currentBranch}`,
-    ]);
-    logger.debug({ resetLog }, 'git reset log');
-    const pushLog = await git.push(['origin', config.currentBranch, '--force']);
-    logger.debug({ pushLog }, 'git push log');
-    await fetchBranchCommits(false);
-  }
-  config.currentBranchSha = (
-    await git.raw(['rev-parse', 'HEAD'])
-  ).trim() as LongCommitSha;
-  logger.debug(`Current branch SHA: ${config.currentBranchSha}`);
 }
 
 export async function getRepoStatus(path?: string): Promise<StatusResult> {

lib/util/git/types.ts

@@ -19,7 +19,6 @@ export interface StorageConfig {
   currentBranch?: string;
   defaultBranch?: string;
   url: string;
-  upstreamUrl?: string;
   extraCloneOpts?: GitOptions;
   cloneSubmodules?: boolean;
   cloneSubmodulesFilter?: string[];