BareSuperprojectWriter.java

  1. /*
  2.  * Copyright (C) 2021, Google Inc. and others
  3.  *
  4.  * This program and the accompanying materials are made available under the
  5.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  6.  * https://www.eclipse.org/org/documents/edl-v10.php.
  7.  *
  8.  * SPDX-License-Identifier: BSD-3-Clause
  9.  */
  10. package org.eclipse.jgit.gitrepo;

  12. import static java.nio.charset.StandardCharsets.UTF_8;
  13. import static org.eclipse.jgit.lib.Constants.R_TAGS;

  15. import java.io.IOException;
  16. import java.net.URI;
  17. import java.text.MessageFormat;
  18. import java.util.List;

  20. import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
  21. import org.eclipse.jgit.api.errors.GitAPIException;
  22. import org.eclipse.jgit.api.errors.JGitInternalException;
  23. import org.eclipse.jgit.dircache.DirCache;
  24. import org.eclipse.jgit.dircache.DirCacheBuilder;
  25. import org.eclipse.jgit.dircache.DirCacheEntry;
  26. import org.eclipse.jgit.dircache.InvalidPathException;
  27. import org.eclipse.jgit.gitrepo.RepoCommand.ManifestErrorException;
  28. import org.eclipse.jgit.gitrepo.RepoCommand.RemoteFile;
  29. import org.eclipse.jgit.gitrepo.RepoCommand.RemoteReader;
  30. import org.eclipse.jgit.gitrepo.RepoCommand.RemoteUnavailableException;
  31. import org.eclipse.jgit.gitrepo.RepoProject.CopyFile;
  32. import org.eclipse.jgit.gitrepo.RepoProject.LinkFile;
  33. import org.eclipse.jgit.gitrepo.internal.RepoText;
  34. import org.eclipse.jgit.internal.JGitText;
  35. import org.eclipse.jgit.lib.CommitBuilder;
  36. import org.eclipse.jgit.lib.Config;
  37. import org.eclipse.jgit.lib.Constants;
  38. import org.eclipse.jgit.lib.FileMode;
  39. import org.eclipse.jgit.lib.ObjectId;
  40. import org.eclipse.jgit.lib.ObjectInserter;
  41. import org.eclipse.jgit.lib.PersonIdent;
  42. import org.eclipse.jgit.lib.RefUpdate;
  43. import org.eclipse.jgit.lib.RefUpdate.Result;
  44. import org.eclipse.jgit.lib.Repository;
  45. import org.eclipse.jgit.revwalk.RevCommit;
  46. import org.eclipse.jgit.revwalk.RevWalk;
  47. import org.eclipse.jgit.util.FileUtils;

  49. /**
  50.  * Writes .gitmodules and gitlinks of parsed manifest projects into a bare
  51.  * repository.
  52.  *
  53.  * To write on a regular repository, see {@link RegularSuperprojectWriter}.
  54.  */
  55. class BareSuperprojectWriter {
  56.     private static final int LOCK_FAILURE_MAX_RETRIES = 5;

  58.     // Retry exponentially with delays in this range
  59.     private static final int LOCK_FAILURE_MIN_RETRY_DELAY_MILLIS = 50;

  61.     private static final int LOCK_FAILURE_MAX_RETRY_DELAY_MILLIS = 5000;

  63.     private final Repository repo;

  65.     private final URI targetUri;

  67.     private final String targetBranch;

  69.     private final RemoteReader callback;

  71.     private final BareWriterConfig config;

  73.     private final PersonIdent author;

  75.     private List<ExtraContent> extraContents;

  77.     static class BareWriterConfig {
  78.         boolean ignoreRemoteFailures = false;

  80.         boolean recordRemoteBranch = true;

  82.         boolean recordSubmoduleLabels = true;

  84.         boolean recordShallowSubmodules = true;

  86.         static BareWriterConfig getDefault() {
  87.             return new BareWriterConfig();
  88.         }

  90.         private BareWriterConfig() {
  91.         }
  92.     }

  94.     static class ExtraContent {
  95.         final String path;

  97.         final String content;

  99.         ExtraContent(String path, String content) {
  100.             this.path = path;
  101.             this.content = content;
  102.         }
  103.     }

  105.     BareSuperprojectWriter(Repository repo, URI targetUri,
  106.             String targetBranch,
  107.             PersonIdent author, RemoteReader callback,
  108.             BareWriterConfig config,
  109.             List<ExtraContent> extraContents) {
  110.         assert (repo.isBare());
  111.         this.repo = repo;
  112.         this.targetUri = targetUri;
  113.         this.targetBranch = targetBranch;
  114.         this.author = author;
  115.         this.callback = callback;
  116.         this.config = config;
  117.         this.extraContents = extraContents;
  118.     }

  120.     RevCommit write(List<RepoProject> repoProjects)
  121.             throws GitAPIException {
  122.         DirCache index = DirCache.newInCore();
  123.         ObjectInserter inserter = repo.newObjectInserter();

  125.         try (RevWalk rw = new RevWalk(repo)) {
  126.             prepareIndex(repoProjects, index, inserter);
  127.             ObjectId treeId = index.writeTree(inserter);
  128.             long prevDelay = 0;
  129.             for (int i = 0; i < LOCK_FAILURE_MAX_RETRIES - 1; i++) {
  130.                 try {
  131.                     return commitTreeOnCurrentTip(inserter, rw, treeId);
  132.                 } catch (ConcurrentRefUpdateException e) {
  133.                     prevDelay = FileUtils.delay(prevDelay,
  134.                             LOCK_FAILURE_MIN_RETRY_DELAY_MILLIS,
  135.                             LOCK_FAILURE_MAX_RETRY_DELAY_MILLIS);
  136.                     Thread.sleep(prevDelay);
  137.                     repo.getRefDatabase().refresh();
  138.                 }
  139.             }
  140.             // In the last try, just propagate the exceptions
  141.             return commitTreeOnCurrentTip(inserter, rw, treeId);
  142.         } catch (IOException | InterruptedException | InvalidPathException e) {
  143.             throw new ManifestErrorException(e);
  144.         }
  145.     }

  147.     private void prepareIndex(List<RepoProject> projects, DirCache index,
  148.             ObjectInserter inserter) throws IOException, GitAPIException {
  149.         Config cfg = new Config();
  150.         StringBuilder attributes = new StringBuilder();
  151.         DirCacheBuilder builder = index.builder();
  152.         for (RepoProject proj : projects) {
  153.             String name = proj.getName();
  154.             String path = proj.getPath();
  155.             String url = proj.getUrl();
  156.             ObjectId objectId;
  157.             if (ObjectId.isId(proj.getRevision())) {
  158.                 objectId = ObjectId.fromString(proj.getRevision());
  159.             } else {
  160.                 objectId = callback.sha1(url, proj.getRevision());
  161.                 if (objectId == null && !config.ignoreRemoteFailures) {
  162.                     throw new RemoteUnavailableException(url);
  163.                 }
  164.                 if (config.recordRemoteBranch) {
  165.                     // "branch" field is only for non-tag references.
  166.                     // Keep tags in "ref" field as hint for other tools.
  167.                     String field = proj.getRevision().startsWith(R_TAGS) ? "ref" //$NON-NLS-1$
  168.                             : "branch"; //$NON-NLS-1$
  169.                     cfg.setString("submodule", name, field, //$NON-NLS-1$
  170.                             proj.getRevision());
  171.                 }

  173.                 if (config.recordShallowSubmodules
  174.                         && proj.getRecommendShallow() != null) {
  175.                     // The shallow recommendation is losing information.
  176.                     // As the repo manifests stores the recommended
  177.                     // depth in the 'clone-depth' field, while
  178.                     // git core only uses a binary 'shallow = true/false'
  179.                     // hint, we'll map any depth to 'shallow = true'
  180.                     cfg.setBoolean("submodule", name, "shallow", //$NON-NLS-1$ //$NON-NLS-2$
  181.                             true);
  182.                 }
  183.             }
  184.             if (config.recordSubmoduleLabels) {
  185.                 StringBuilder rec = new StringBuilder();
  186.                 rec.append("/"); //$NON-NLS-1$
  187.                 rec.append(path);
  188.                 for (String group : proj.getGroups()) {
  189.                     rec.append(" "); //$NON-NLS-1$
  190.                     rec.append(group);
  191.                 }
  192.                 rec.append("\n"); //$NON-NLS-1$
  193.                 attributes.append(rec.toString());
  194.             }

  196.             URI submodUrl = URI.create(url);
  197.             if (targetUri != null) {
  198.                 submodUrl = RepoCommand.relativize(targetUri, submodUrl);
  199.             }
  200.             cfg.setString("submodule", name, "path", path); //$NON-NLS-1$ //$NON-NLS-2$
  201.             cfg.setString("submodule", name, "url", //$NON-NLS-1$ //$NON-NLS-2$
  202.                     submodUrl.toString());

  204.             // create gitlink
  205.             if (objectId != null) {
  206.                 DirCacheEntry dcEntry = new DirCacheEntry(path);
  207.                 dcEntry.setObjectId(objectId);
  208.                 dcEntry.setFileMode(FileMode.GITLINK);
  209.                 builder.add(dcEntry);

  211.                 for (CopyFile copyfile : proj.getCopyFiles()) {
  212.                     RemoteFile rf = callback.readFileWithMode(url,
  213.                             proj.getRevision(), copyfile.src);
  214.                     objectId = inserter.insert(Constants.OBJ_BLOB,
  215.                             rf.getContents());
  216.                     dcEntry = new DirCacheEntry(copyfile.dest);
  217.                     dcEntry.setObjectId(objectId);
  218.                     dcEntry.setFileMode(rf.getFileMode());
  219.                     builder.add(dcEntry);
  220.                 }
  221.                 for (LinkFile linkfile : proj.getLinkFiles()) {
  222.                     String link;
  223.                     if (linkfile.dest.contains("/")) { //$NON-NLS-1$
  224.                         link = FileUtils.relativizeGitPath(
  225.                                 linkfile.dest.substring(0,
  226.                                         linkfile.dest.lastIndexOf('/')),
  227.                                 proj.getPath() + "/" + linkfile.src); //$NON-NLS-1$
  228.                     } else {
  229.                         link = proj.getPath() + "/" + linkfile.src; //$NON-NLS-1$
  230.                     }

  232.                     objectId = inserter.insert(Constants.OBJ_BLOB,
  233.                             link.getBytes(UTF_8));
  234.                     dcEntry = new DirCacheEntry(linkfile.dest);
  235.                     dcEntry.setObjectId(objectId);
  236.                     dcEntry.setFileMode(FileMode.SYMLINK);
  237.                     builder.add(dcEntry);
  238.                 }
  239.             }
  240.         }
  241.         String content = cfg.toText();

  243.         // create a new DirCacheEntry for .gitmodules file.
  244.         DirCacheEntry dcEntry = new DirCacheEntry(
  245.                 Constants.DOT_GIT_MODULES);
  246.         ObjectId objectId = inserter.insert(Constants.OBJ_BLOB,
  247.                 content.getBytes(UTF_8));
  248.         dcEntry.setObjectId(objectId);
  249.         dcEntry.setFileMode(FileMode.REGULAR_FILE);
  250.         builder.add(dcEntry);

  252.         if (config.recordSubmoduleLabels) {
  253.             // create a new DirCacheEntry for .gitattributes file.
  254.             DirCacheEntry dcEntryAttr = new DirCacheEntry(
  255.                     Constants.DOT_GIT_ATTRIBUTES);
  256.             ObjectId attrId = inserter.insert(Constants.OBJ_BLOB,
  257.                     attributes.toString().getBytes(UTF_8));
  258.             dcEntryAttr.setObjectId(attrId);
  259.             dcEntryAttr.setFileMode(FileMode.REGULAR_FILE);
  260.             builder.add(dcEntryAttr);
  261.         }

  263.         for (ExtraContent ec : extraContents) {
  264.             DirCacheEntry extraDcEntry = new DirCacheEntry(ec.path);

  266.             ObjectId oid = inserter.insert(Constants.OBJ_BLOB,
  267.                     ec.content.getBytes(UTF_8));
  268.             extraDcEntry.setObjectId(oid);
  269.             extraDcEntry.setFileMode(FileMode.REGULAR_FILE);
  270.             builder.add(extraDcEntry);
  271.         }

  273.         builder.finish();
  274.     }

  276.     private RevCommit commitTreeOnCurrentTip(ObjectInserter inserter,
  277.             RevWalk rw, ObjectId treeId)
  278.             throws IOException, ConcurrentRefUpdateException {
  279.         ObjectId headId = repo.resolve(targetBranch + "^{commit}"); //$NON-NLS-1$
  280.         if (headId != null
  281.                 && rw.parseCommit(headId).getTree().getId().equals(treeId)) {
  282.             // No change. Do nothing.
  283.             return rw.parseCommit(headId);
  284.         }

  286.         CommitBuilder commit = new CommitBuilder();
  287.         commit.setTreeId(treeId);
  288.         if (headId != null) {
  289.             commit.setParentIds(headId);
  290.         }
  291.         commit.setAuthor(author);
  292.         commit.setCommitter(author);
  293.         commit.setMessage(RepoText.get().repoCommitMessage);

  295.         ObjectId commitId = inserter.insert(commit);
  296.         inserter.flush();

  298.         RefUpdate ru = repo.updateRef(targetBranch);
  299.         ru.setNewObjectId(commitId);
  300.         ru.setExpectedOldObjectId(headId != null ? headId : ObjectId.zeroId());
  301.         Result rc = ru.update(rw);
  302.         switch (rc) {
  303.         case NEW:
  304.         case FORCED:
  305.         case FAST_FORWARD:
  306.             // Successful. Do nothing.
  307.             break;
  308.         case REJECTED:
  309.         case LOCK_FAILURE:
  310.             throw new ConcurrentRefUpdateException(MessageFormat.format(
  311.                     JGitText.get().cannotLock, targetBranch), ru.getRef(), rc);
  312.         default:
  313.             throw new JGitInternalException(
  314.                     MessageFormat.format(JGitText.get().updatingRefFailed,
  315.                             targetBranch, commitId.name(), rc));
  316.         }

  318.         return rw.parseCommit(commitId);
  319.     }
  320. }
Created with JaCoCo 0.8.7.202105040129