RefDirectory.java

  1. /*
  2.  * Copyright (C) 2007, Dave Watson <dwatson@mimvista.com>
  3.  * Copyright (C) 2009-2010, Google Inc.
  4.  * Copyright (C) 2007, Robin Rosenberg <robin.rosenberg@dewire.com>
  5.  * Copyright (C) 2006, Shawn O. Pearce <spearce@spearce.org> and others
  6.  *
  7.  * This program and the accompanying materials are made available under the
  8.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  9.  * https://www.eclipse.org/org/documents/edl-v10.php.
  10.  *
  11.  * SPDX-License-Identifier: BSD-3-Clause
  12.  */

  14. package org.eclipse.jgit.internal.storage.file;

  16. import static java.nio.charset.StandardCharsets.UTF_8;
  17. import static org.eclipse.jgit.lib.Constants.HEAD;
  18. import static org.eclipse.jgit.lib.Constants.LOGS;
  19. import static org.eclipse.jgit.lib.Constants.OBJECT_ID_STRING_LENGTH;
  20. import static org.eclipse.jgit.lib.Constants.PACKED_REFS;
  21. import static org.eclipse.jgit.lib.Constants.R_HEADS;
  22. import static org.eclipse.jgit.lib.Constants.R_REFS;
  23. import static org.eclipse.jgit.lib.Constants.R_TAGS;
  24. import static org.eclipse.jgit.lib.Ref.Storage.LOOSE;
  25. import static org.eclipse.jgit.lib.Ref.Storage.NEW;
  26. import static org.eclipse.jgit.lib.Ref.Storage.PACKED;

  28. import java.io.BufferedReader;
  29. import java.io.File;
  30. import java.io.FileInputStream;
  31. import java.io.IOException;
  32. import java.io.InputStreamReader;
  33. import java.io.InterruptedIOException;
  34. import java.nio.file.DirectoryNotEmptyException;
  35. import java.nio.file.Files;
  36. import java.nio.file.Path;
  37. import java.security.DigestInputStream;
  38. import java.security.MessageDigest;
  39. import java.text.MessageFormat;
  40. import java.util.Arrays;
  41. import java.util.Collection;
  42. import java.util.Collections;
  43. import java.util.HashMap;
  44. import java.util.LinkedList;
  45. import java.util.List;
  46. import java.util.Map;
  47. import java.util.concurrent.atomic.AtomicInteger;
  48. import java.util.concurrent.atomic.AtomicReference;
  49. import java.util.concurrent.locks.ReentrantLock;
  50. import java.util.stream.Stream;

  52. import org.eclipse.jgit.annotations.NonNull;
  53. import org.eclipse.jgit.annotations.Nullable;
  54. import org.eclipse.jgit.errors.InvalidObjectIdException;
  55. import org.eclipse.jgit.errors.LockFailedException;
  56. import org.eclipse.jgit.errors.MissingObjectException;
  57. import org.eclipse.jgit.errors.ObjectWritingException;
  58. import org.eclipse.jgit.events.RefsChangedEvent;
  59. import org.eclipse.jgit.internal.JGitText;
  60. import org.eclipse.jgit.lib.ConfigConstants;
  61. import org.eclipse.jgit.lib.Constants;
  62. import org.eclipse.jgit.lib.ObjectId;
  63. import org.eclipse.jgit.lib.ObjectIdRef;
  64. import org.eclipse.jgit.lib.Ref;
  65. import org.eclipse.jgit.lib.RefComparator;
  66. import org.eclipse.jgit.lib.RefDatabase;
  67. import org.eclipse.jgit.lib.RefUpdate;
  68. import org.eclipse.jgit.lib.RefWriter;
  69. import org.eclipse.jgit.lib.Repository;
  70. import org.eclipse.jgit.lib.SymbolicRef;
  71. import org.eclipse.jgit.revwalk.RevObject;
  72. import org.eclipse.jgit.revwalk.RevTag;
  73. import org.eclipse.jgit.revwalk.RevWalk;
  74. import org.eclipse.jgit.util.FS;
  75. import org.eclipse.jgit.util.FileUtils;
  76. import org.eclipse.jgit.util.IO;
  77. import org.eclipse.jgit.util.RawParseUtils;
  78. import org.eclipse.jgit.util.RefList;
  79. import org.eclipse.jgit.util.RefMap;
  80. import org.slf4j.Logger;
  81. import org.slf4j.LoggerFactory;

  83. /**
  84.  * Traditional file system based {@link org.eclipse.jgit.lib.RefDatabase}.
  85.  * <p>
  86.  * This is the classical reference database representation for a Git repository.
  87.  * References are stored in two formats: loose, and packed.
  88.  * <p>
  89.  * Loose references are stored as individual files within the {@code refs/}
  90.  * directory. The file name matches the reference name and the file contents is
  91.  * the current {@link org.eclipse.jgit.lib.ObjectId} in string form.
  92.  * <p>
  93.  * Packed references are stored in a single text file named {@code packed-refs}.
  94.  * In the packed format, each reference is stored on its own line. This file
  95.  * reduces the number of files needed for large reference spaces, reducing the
  96.  * overall size of a Git repository on disk.
  97.  */
  98. public class RefDirectory extends RefDatabase {
  99.     private static final Logger LOG = LoggerFactory
  100.             .getLogger(RefDirectory.class);

  102.     /** Magic string denoting the start of a symbolic reference file. */
  103.     public static final String SYMREF = "ref: "; //$NON-NLS-1$

  105.     /** Magic string denoting the header of a packed-refs file. */
  106.     public static final String PACKED_REFS_HEADER = "# pack-refs with:"; //$NON-NLS-1$

  108.     /** If in the header, denotes the file has peeled data. */
  109.     public static final String PACKED_REFS_PEELED = " peeled"; //$NON-NLS-1$

  111.     /** The names of the additional refs supported by this class */
  112.     private static final String[] additionalRefsNames = new String[] {
  113.             Constants.MERGE_HEAD, Constants.FETCH_HEAD, Constants.ORIG_HEAD,
  114.             Constants.CHERRY_PICK_HEAD };

  116.     @SuppressWarnings("boxing")
  117.     private static final List<Integer> RETRY_SLEEP_MS =
  118.             Collections.unmodifiableList(Arrays.asList(0, 100, 200, 400, 800, 1600));

  120.     private final FileRepository parent;

  122.     private final File gitDir;

  124.     final File refsDir;

  126.     final File packedRefsFile;

  128.     final File logsDir;

  130.     final File logsRefsDir;

  132.     /**
  133.      * Immutable sorted list of loose references.
  134.      * <p>
  135.      * Symbolic references in this collection are stored unresolved, that is
  136.      * their target appears to be a new reference with no ObjectId. These are
  137.      * converted into resolved references during a get operation, ensuring the
  138.      * live value is always returned.
  139.      */
  140.     private final AtomicReference<RefList<LooseRef>> looseRefs = new AtomicReference<>();

  142.     /** Immutable sorted list of packed references. */
  143.     final AtomicReference<PackedRefList> packedRefs = new AtomicReference<>();

  145.     /**
  146.      * Lock for coordinating operations within a single process that may contend
  147.      * on the {@code packed-refs} file.
  148.      * <p>
  149.      * All operations that write {@code packed-refs} must still acquire a
  150.      * {@link LockFile} on {@link #packedRefsFile}, even after they have acquired
  151.      * this lock, since there may be multiple {@link RefDirectory} instances or
  152.      * other processes operating on the same repo on disk.
  153.      * <p>
  154.      * This lock exists so multiple threads in the same process can wait in a fair
  155.      * queue without trying, failing, and retrying to acquire the on-disk lock. If
  156.      * {@code RepositoryCache} is used, this lock instance will be used by all
  157.      * threads.
  158.      */
  159.     final ReentrantLock inProcessPackedRefsLock = new ReentrantLock(true);

  161.     /**
  162.      * Number of modifications made to this database.
  163.      * <p>
  164.      * This counter is incremented when a change is made, or detected from the
  165.      * filesystem during a read operation.
  166.      */
  167.     private final AtomicInteger modCnt = new AtomicInteger();

  169.     /**
  170.      * Last {@link #modCnt} that we sent to listeners.
  171.      * <p>
  172.      * This value is compared to {@link #modCnt}, and a notification is sent to
  173.      * the listeners only when it differs.
  174.      */
  175.     private final AtomicInteger lastNotifiedModCnt = new AtomicInteger();

  177.     private List<Integer> retrySleepMs = RETRY_SLEEP_MS;

  179.     RefDirectory(FileRepository db) {
  180.         final FS fs = db.getFS();
  181.         parent = db;
  182.         gitDir = db.getDirectory();
  183.         refsDir = fs.resolve(gitDir, R_REFS);
  184.         logsDir = fs.resolve(gitDir, LOGS);
  185.         logsRefsDir = fs.resolve(gitDir, LOGS + '/' + R_REFS);
  186.         packedRefsFile = fs.resolve(gitDir, PACKED_REFS);

  188.         looseRefs.set(RefList.<LooseRef> emptyList());
  189.         packedRefs.set(NO_PACKED_REFS);
  190.     }

  192.     Repository getRepository() {
  193.         return parent;
  194.     }

  196.     ReflogWriter newLogWriter(boolean force) {
  197.         return new ReflogWriter(this, force);
  198.     }

  200.     /**
  201.      * Locate the log file on disk for a single reference name.
  202.      *
  203.      * @param name
  204.      *            name of the ref, relative to the Git repository top level
  205.      *            directory (so typically starts with refs/).
  206.      * @return the log file location.
  207.      */
  208.     public File logFor(String name) {
  209.         if (name.startsWith(R_REFS)) {
  210.             name = name.substring(R_REFS.length());
  211.             return new File(logsRefsDir, name);
  212.         }
  213.         return new File(logsDir, name);
  214.     }

  216.     /** {@inheritDoc} */
  217.     @Override
  218.     public void create() throws IOException {
  219.         FileUtils.mkdir(refsDir);
  220.         FileUtils.mkdir(new File(refsDir, R_HEADS.substring(R_REFS.length())));
  221.         FileUtils.mkdir(new File(refsDir, R_TAGS.substring(R_REFS.length())));
  222.         newLogWriter(false).create();
  223.     }

  225.     /** {@inheritDoc} */
  226.     @Override
  227.     public void close() {
  228.         clearReferences();
  229.     }

  231.     private void clearReferences() {
  232.         looseRefs.set(RefList.<LooseRef> emptyList());
  233.         packedRefs.set(NO_PACKED_REFS);
  234.     }

  236.     /** {@inheritDoc} */
  237.     @Override
  238.     public void refresh() {
  239.         super.refresh();
  240.         clearReferences();
  241.     }

  243.     /** {@inheritDoc} */
  244.     @Override
  245.     public boolean isNameConflicting(String name) throws IOException {
  246.         // Cannot be nested within an existing reference.
  247.         int lastSlash = name.lastIndexOf('/');
  248.         while (0 < lastSlash) {
  249.             String needle = name.substring(0, lastSlash);
  250.             if (exactRef(needle) != null) {
  251.                 return true;
  252.             }
  253.             lastSlash = name.lastIndexOf('/', lastSlash - 1);
  254.         }

  256.         // Cannot be the container of an existing reference.
  257.         return !getRefsByPrefix(name + '/').isEmpty();
  258.     }

  260.     @Nullable
  261.     private Ref readAndResolve(String name, RefList<Ref> packed) throws IOException {
  262.         try {
  263.             Ref ref = readRef(name, packed);
  264.             if (ref != null) {
  265.                 ref = resolve(ref, 0, null, null, packed);
  266.             }
  267.             return ref;
  268.         } catch (IOException e) {
  269.             if (name.contains("/") //$NON-NLS-1$
  270.                     || !(e.getCause() instanceof InvalidObjectIdException)) {
  271.                 throw e;
  272.             }

  274.             // While looking for a ref outside of refs/ (e.g., 'config'), we
  275.             // found a non-ref file (e.g., a config file) instead.  Treat this
  276.             // as a ref-not-found condition.
  277.             return null;
  278.         }
  279.     }

  281.     /** {@inheritDoc} */
  282.     @Override
  283.     public Ref exactRef(String name) throws IOException {
  284.         try {
  285.             return readAndResolve(name, getPackedRefs());
  286.         } finally {
  287.             fireRefsChanged();
  288.         }
  289.     }

  291.     /** {@inheritDoc} */
  292.     @Override
  293.     @NonNull
  294.     public Map<String, Ref> exactRef(String... refs) throws IOException {
  295.         try {
  296.             RefList<Ref> packed = getPackedRefs();
  297.             Map<String, Ref> result = new HashMap<>(refs.length);
  298.             for (String name : refs) {
  299.                 Ref ref = readAndResolve(name, packed);
  300.                 if (ref != null) {
  301.                     result.put(name, ref);
  302.                 }
  303.             }
  304.             return result;
  305.         } finally {
  306.             fireRefsChanged();
  307.         }
  308.     }

  310.     /** {@inheritDoc} */
  311.     @Override
  312.     @Nullable
  313.     public Ref firstExactRef(String... refs) throws IOException {
  314.         try {
  315.             RefList<Ref> packed = getPackedRefs();
  316.             for (String name : refs) {
  317.                 Ref ref = readAndResolve(name, packed);
  318.                 if (ref != null) {
  319.                     return ref;
  320.                 }
  321.             }
  322.             return null;
  323.         } finally {
  324.             fireRefsChanged();
  325.         }
  326.     }

  328.     /** {@inheritDoc} */
  329.     @Override
  330.     public Map<String, Ref> getRefs(String prefix) throws IOException {
  331.         final RefList<LooseRef> oldLoose = looseRefs.get();
  332.         LooseScanner scan = new LooseScanner(oldLoose);
  333.         scan.scan(prefix);
  334.         final RefList<Ref> packed = getPackedRefs();

  336.         RefList<LooseRef> loose;
  337.         if (scan.newLoose != null) {
  338.             scan.newLoose.sort();
  339.             loose = scan.newLoose.toRefList();
  340.             if (looseRefs.compareAndSet(oldLoose, loose))
  341.                 modCnt.incrementAndGet();
  342.         } else
  343.             loose = oldLoose;
  344.         fireRefsChanged();

  346.         RefList.Builder<Ref> symbolic = scan.symbolic;
  347.         for (int idx = 0; idx < symbolic.size();) {
  348.             final Ref symbolicRef = symbolic.get(idx);
  349.             final Ref resolvedRef = resolve(symbolicRef, 0, prefix, loose, packed);
  350.             if (resolvedRef != null && resolvedRef.getObjectId() != null) {
  351.                 symbolic.set(idx, resolvedRef);
  352.                 idx++;
  353.             } else {
  354.                 // A broken symbolic reference, we have to drop it from the
  355.                 // collections the client is about to receive. Should be a
  356.                 // rare occurrence so pay a copy penalty.
  357.                 symbolic.remove(idx);
  358.                 final int toRemove = loose.find(symbolicRef.getName());
  359.                 if (0 <= toRemove)
  360.                     loose = loose.remove(toRemove);
  361.             }
  362.         }
  363.         symbolic.sort();

  365.         return new RefMap(prefix, packed, upcast(loose), symbolic.toRefList());
  366.     }

  368.     /** {@inheritDoc} */
  369.     @Override
  370.     public List<Ref> getAdditionalRefs() throws IOException {
  371.         List<Ref> ret = new LinkedList<>();
  372.         for (String name : additionalRefsNames) {
  373.             Ref r = exactRef(name);
  374.             if (r != null)
  375.                 ret.add(r);
  376.         }
  377.         return ret;
  378.     }

  380.     @SuppressWarnings("unchecked")
  381.     private RefList<Ref> upcast(RefList<? extends Ref> loose) {
  382.         return (RefList<Ref>) loose;
  383.     }

  385.     private class LooseScanner {
  386.         private final RefList<LooseRef> curLoose;

  388.         private int curIdx;

  390.         final RefList.Builder<Ref> symbolic = new RefList.Builder<>(4);

  392.         RefList.Builder<LooseRef> newLoose;

  394.         LooseScanner(RefList<LooseRef> curLoose) {
  395.             this.curLoose = curLoose;
  396.         }

  398.         void scan(String prefix) {
  399.             if (ALL.equals(prefix)) {
  400.                 scanOne(HEAD);
  401.                 scanTree(R_REFS, refsDir);

  403.                 // If any entries remain, they are deleted, drop them.
  404.                 if (newLoose == null && curIdx < curLoose.size())
  405.                     newLoose = curLoose.copy(curIdx);

  407.             } else if (prefix.startsWith(R_REFS) && prefix.endsWith("/")) { //$NON-NLS-1$
  408.                 curIdx = -(curLoose.find(prefix) + 1);
  409.                 File dir = new File(refsDir, prefix.substring(R_REFS.length()));
  410.                 scanTree(prefix, dir);

  412.                 // Skip over entries still within the prefix; these have
  413.                 // been removed from the directory.
  414.                 while (curIdx < curLoose.size()) {
  415.                     if (!curLoose.get(curIdx).getName().startsWith(prefix))
  416.                         break;
  417.                     if (newLoose == null)
  418.                         newLoose = curLoose.copy(curIdx);
  419.                     curIdx++;
  420.                 }

  422.                 // Keep any entries outside of the prefix space, we
  423.                 // do not know anything about their status.
  424.                 if (newLoose != null) {
  425.                     while (curIdx < curLoose.size())
  426.                         newLoose.add(curLoose.get(curIdx++));
  427.                 }
  428.             }
  429.         }

  431.         private boolean scanTree(String prefix, File dir) {
  432.             final String[] entries = dir.list(LockFile.FILTER);
  433.             if (entries == null) // not a directory or an I/O error
  434.                 return false;
  435.             if (0 < entries.length) {
  436.                 for (int i = 0; i < entries.length; ++i) {
  437.                     String e = entries[i];
  438.                     File f = new File(dir, e);
  439.                     if (f.isDirectory())
  440.                         entries[i] += '/';
  441.                 }
  442.                 Arrays.sort(entries);
  443.                 for (String name : entries) {
  444.                     if (name.charAt(name.length() - 1) == '/')
  445.                         scanTree(prefix + name, new File(dir, name));
  446.                     else
  447.                         scanOne(prefix + name);
  448.                 }
  449.             }
  450.             return true;
  451.         }

  453.         private void scanOne(String name) {
  454.             LooseRef cur;

  456.             if (curIdx < curLoose.size()) {
  457.                 do {
  458.                     cur = curLoose.get(curIdx);
  459.                     int cmp = RefComparator.compareTo(cur, name);
  460.                     if (cmp < 0) {
  461.                         // Reference is not loose anymore, its been deleted.
  462.                         // Skip the name in the new result list.
  463.                         if (newLoose == null)
  464.                             newLoose = curLoose.copy(curIdx);
  465.                         curIdx++;
  466.                         cur = null;
  467.                         continue;
  468.                     }

  470.                     if (cmp > 0) // Newly discovered loose reference.
  471.                         cur = null;
  472.                     break;
  473.                 } while (curIdx < curLoose.size());
  474.             } else
  475.                 cur = null; // Newly discovered loose reference.

  477.             LooseRef n;
  478.             try {
  479.                 n = scanRef(cur, name);
  480.             } catch (IOException notValid) {
  481.                 n = null;
  482.             }

  484.             if (n != null) {
  485.                 if (cur != n && newLoose == null)
  486.                     newLoose = curLoose.copy(curIdx);
  487.                 if (newLoose != null)
  488.                     newLoose.add(n);
  489.                 if (n.isSymbolic())
  490.                     symbolic.add(n);
  491.             } else if (cur != null) {
  492.                 // Tragically, this file is no longer a loose reference.
  493.                 // Kill our cached entry of it.
  494.                 if (newLoose == null)
  495.                     newLoose = curLoose.copy(curIdx);
  496.             }

  498.             if (cur != null)
  499.                 curIdx++;
  500.         }
  501.     }

  503.     /** {@inheritDoc} */
  504.     @Override
  505.     public Ref peel(Ref ref) throws IOException {
  506.         final Ref leaf = ref.getLeaf();
  507.         if (leaf.isPeeled() || leaf.getObjectId() == null)
  508.             return ref;

  510.         ObjectIdRef newLeaf = doPeel(leaf);

  512.         // Try to remember this peeling in the cache, so we don't have to do
  513.         // it again in the future, but only if the reference is unchanged.
  514.         if (leaf.getStorage().isLoose()) {
  515.             RefList<LooseRef> curList = looseRefs.get();
  516.             int idx = curList.find(leaf.getName());
  517.             if (0 <= idx && curList.get(idx) == leaf) {
  518.                 LooseRef asPeeled = ((LooseRef) leaf).peel(newLeaf);
  519.                 RefList<LooseRef> newList = curList.set(idx, asPeeled);
  520.                 looseRefs.compareAndSet(curList, newList);
  521.             }
  522.         }

  524.         return recreate(ref, newLeaf);
  525.     }

  527.     private ObjectIdRef doPeel(Ref leaf) throws MissingObjectException,
  528.             IOException {
  529.         try (RevWalk rw = new RevWalk(getRepository())) {
  530.             RevObject obj = rw.parseAny(leaf.getObjectId());
  531.             if (obj instanceof RevTag) {
  532.                 return new ObjectIdRef.PeeledTag(leaf.getStorage(), leaf
  533.                         .getName(), leaf.getObjectId(), rw.peel(obj).copy());
  534.             }
  535.             return new ObjectIdRef.PeeledNonTag(leaf.getStorage(),
  536.                     leaf.getName(), leaf.getObjectId());
  537.         }
  538.     }

  540.     private static Ref recreate(Ref old, ObjectIdRef leaf) {
  541.         if (old.isSymbolic()) {
  542.             Ref dst = recreate(old.getTarget(), leaf);
  543.             return new SymbolicRef(old.getName(), dst);
  544.         }
  545.         return leaf;
  546.     }

  548.     void storedSymbolicRef(RefDirectoryUpdate u, FileSnapshot snapshot,
  549.             String target) {
  550.         putLooseRef(newSymbolicRef(snapshot, u.getRef().getName(), target));
  551.         fireRefsChanged();
  552.     }

  554.     /** {@inheritDoc} */
  555.     @Override
  556.     public RefDirectoryUpdate newUpdate(String name, boolean detach)
  557.             throws IOException {
  558.         boolean detachingSymbolicRef = false;
  559.         final RefList<Ref> packed = getPackedRefs();
  560.         Ref ref = readRef(name, packed);
  561.         if (ref != null)
  562.             ref = resolve(ref, 0, null, null, packed);
  563.         if (ref == null)
  564.             ref = new ObjectIdRef.Unpeeled(NEW, name, null);
  565.         else {
  566.             detachingSymbolicRef = detach && ref.isSymbolic();
  567.         }
  568.         RefDirectoryUpdate refDirUpdate = new RefDirectoryUpdate(this, ref);
  569.         if (detachingSymbolicRef)
  570.             refDirUpdate.setDetachingSymbolicRef();
  571.         return refDirUpdate;
  572.     }

  574.     /** {@inheritDoc} */
  575.     @Override
  576.     public RefDirectoryRename newRename(String fromName, String toName)
  577.             throws IOException {
  578.         RefDirectoryUpdate from = newUpdate(fromName, false);
  579.         RefDirectoryUpdate to = newUpdate(toName, false);
  580.         return new RefDirectoryRename(from, to);
  581.     }

  583.     /** {@inheritDoc} */
  584.     @Override
  585.     public PackedBatchRefUpdate newBatchUpdate() {
  586.         return new PackedBatchRefUpdate(this);
  587.     }

  589.     /**
  590.      * Create a new batch update to attempt on this database.
  591.      *
  592.      * @param shouldLockLooseRefs
  593.      *            whether loose refs should be locked during the batch ref
  594.      *            update. Note that this should only be set to {@code false} if
  595.      *            the application using this ensures that no other ref updates
  596.      *            run concurrently to avoid lost updates caused by a race. In
  597.      *            such cases it can improve performance.
  598.      * @return a new batch update object
  599.      */
  600.     public PackedBatchRefUpdate newBatchUpdate(boolean shouldLockLooseRefs) {
  601.         return new PackedBatchRefUpdate(this, shouldLockLooseRefs);
  602.     }

  604.     /** {@inheritDoc} */
  605.     @Override
  606.     public boolean performsAtomicTransactions() {
  607.         return true;
  608.     }

  610.     void stored(RefDirectoryUpdate update, FileSnapshot snapshot) {
  611.         final ObjectId target = update.getNewObjectId().copy();
  612.         final Ref leaf = update.getRef().getLeaf();
  613.         putLooseRef(new LooseUnpeeled(snapshot, leaf.getName(), target));
  614.     }

  616.     private void putLooseRef(LooseRef ref) {
  617.         RefList<LooseRef> cList, nList;
  618.         do {
  619.             cList = looseRefs.get();
  620.             nList = cList.put(ref);
  621.         } while (!looseRefs.compareAndSet(cList, nList));
  622.         modCnt.incrementAndGet();
  623.         fireRefsChanged();
  624.     }

  626.     void delete(RefDirectoryUpdate update) throws IOException {
  627.         Ref dst = update.getRef();
  628.         if (!update.isDetachingSymbolicRef()) {
  629.             dst = dst.getLeaf();
  630.         }
  631.         String name = dst.getName();

  633.         // Write the packed-refs file using an atomic update. We might
  634.         // wind up reading it twice, before and after the lock, to ensure
  635.         // we don't miss an edit made externally.
  636.         final PackedRefList packed = getPackedRefs();
  637.         if (packed.contains(name)) {
  638.             inProcessPackedRefsLock.lock();
  639.             try {
  640.                 LockFile lck = lockPackedRefsOrThrow();
  641.                 try {
  642.                     PackedRefList cur = readPackedRefs();
  643.                     int idx = cur.find(name);
  644.                     if (0 <= idx) {
  645.                         commitPackedRefs(lck, cur.remove(idx), packed, true);
  646.                     }
  647.                 } finally {
  648.                     lck.unlock();
  649.                 }
  650.             } finally {
  651.                 inProcessPackedRefsLock.unlock();
  652.             }
  653.         }

  655.         RefList<LooseRef> curLoose, newLoose;
  656.         do {
  657.             curLoose = looseRefs.get();
  658.             int idx = curLoose.find(name);
  659.             if (idx < 0)
  660.                 break;
  661.             newLoose = curLoose.remove(idx);
  662.         } while (!looseRefs.compareAndSet(curLoose, newLoose));

  664.         int levels = levelsIn(name) - 2;
  665.         delete(logFor(name), levels);
  666.         if (dst.getStorage().isLoose()) {
  667.             update.unlock();
  668.             delete(fileFor(name), levels);
  669.         }

  671.         modCnt.incrementAndGet();
  672.         fireRefsChanged();
  673.     }

  675.     /**
  676.      * Adds a set of refs to the set of packed-refs. Only non-symbolic refs are
  677.      * added. If a ref with the given name already existed in packed-refs it is
  678.      * updated with the new value. Each loose ref which was added to the
  679.      * packed-ref file is deleted. If a given ref can't be locked it will not be
  680.      * added to the pack file.
  681.      *
  682.      * @param refs
  683.      *            the refs to be added. Must be fully qualified.
  684.      * @throws java.io.IOException
  685.      */
  686.     public void pack(List<String> refs) throws IOException {
  687.         pack(refs, Collections.emptyMap());
  688.     }

  690.     PackedRefList pack(Map<String, LockFile> heldLocks) throws IOException {
  691.         return pack(heldLocks.keySet(), heldLocks);
  692.     }

  694.     private PackedRefList pack(Collection<String> refs,
  695.             Map<String, LockFile> heldLocks) throws IOException {
  696.         for (LockFile ol : heldLocks.values()) {
  697.             ol.requireLock();
  698.         }
  699.         if (refs.isEmpty()) {
  700.             return null;
  701.         }
  702.         FS fs = parent.getFS();

  704.         // Lock the packed refs file and read the content
  705.         inProcessPackedRefsLock.lock();
  706.         try {
  707.             LockFile lck = lockPackedRefsOrThrow();
  708.             try {
  709.                 final PackedRefList packed = getPackedRefs();
  710.                 RefList<Ref> cur = readPackedRefs();

  712.                 // Iterate over all refs to be packed
  713.                 boolean dirty = false;
  714.                 for (String refName : refs) {
  715.                     Ref oldRef = readRef(refName, cur);
  716.                     if (oldRef == null) {
  717.                         continue; // A non-existent ref is already correctly packed.
  718.                     }
  719.                     if (oldRef.isSymbolic()) {
  720.                         continue; // can't pack symbolic refs
  721.                     }
  722.                     // Add/Update it to packed-refs
  723.                     Ref newRef = peeledPackedRef(oldRef);
  724.                     if (newRef == oldRef) {
  725.                         // No-op; peeledPackedRef returns the input ref only if it's already
  726.                         // packed, and readRef returns a packed ref only if there is no
  727.                         // loose ref.
  728.                         continue;
  729.                     }

  731.                     dirty = true;
  732.                     int idx = cur.find(refName);
  733.                     if (idx >= 0) {
  734.                         cur = cur.set(idx, newRef);
  735.                     } else {
  736.                         cur = cur.add(idx, newRef);
  737.                     }
  738.                 }
  739.                 if (!dirty) {
  740.                     // All requested refs were already packed accurately
  741.                     return packed;
  742.                 }

  744.                 // The new content for packed-refs is collected. Persist it.
  745.                 PackedRefList result = commitPackedRefs(lck, cur, packed,
  746.                         false);

  748.                 // Now delete the loose refs which are now packed
  749.                 for (String refName : refs) {
  750.                     // Lock the loose ref
  751.                     File refFile = fileFor(refName);
  752.                     if (!fs.exists(refFile)) {
  753.                         continue;
  754.                     }

  756.                     LockFile rLck = heldLocks.get(refName);
  757.                     boolean shouldUnlock;
  758.                     if (rLck == null) {
  759.                         rLck = new LockFile(refFile);
  760.                         if (!rLck.lock()) {
  761.                             continue;
  762.                         }
  763.                         shouldUnlock = true;
  764.                     } else {
  765.                         shouldUnlock = false;
  766.                     }

  768.                     try {
  769.                         LooseRef currentLooseRef = scanRef(null, refName);
  770.                         if (currentLooseRef == null || currentLooseRef.isSymbolic()) {
  771.                             continue;
  772.                         }
  773.                         Ref packedRef = cur.get(refName);
  774.                         ObjectId clr_oid = currentLooseRef.getObjectId();
  775.                         if (clr_oid != null
  776.                                 && clr_oid.equals(packedRef.getObjectId())) {
  777.                             RefList<LooseRef> curLoose, newLoose;
  778.                             do {
  779.                                 curLoose = looseRefs.get();
  780.                                 int idx = curLoose.find(refName);
  781.                                 if (idx < 0) {
  782.                                     break;
  783.                                 }
  784.                                 newLoose = curLoose.remove(idx);
  785.                             } while (!looseRefs.compareAndSet(curLoose, newLoose));
  786.                             int levels = levelsIn(refName) - 2;
  787.                             delete(refFile, levels, rLck);
  788.                         }
  789.                     } finally {
  790.                         if (shouldUnlock) {
  791.                             rLck.unlock();
  792.                         }
  793.                     }
  794.                 }
  795.                 // Don't fire refsChanged. The refs have not change, only their
  796.                 // storage.
  797.                 return result;
  798.             } finally {
  799.                 lck.unlock();
  800.             }
  801.         } finally {
  802.             inProcessPackedRefsLock.unlock();
  803.         }
  804.     }

  806.     @Nullable
  807.     LockFile lockPackedRefs() throws IOException {
  808.         LockFile lck = new LockFile(packedRefsFile);
  809.         for (int ms : getRetrySleepMs()) {
  810.             sleep(ms);
  811.             if (lck.lock()) {
  812.                 return lck;
  813.             }
  814.         }
  815.         return null;
  816.     }

  818.     private LockFile lockPackedRefsOrThrow() throws IOException {
  819.         LockFile lck = lockPackedRefs();
  820.         if (lck == null) {
  821.             throw new LockFailedException(packedRefsFile);
  822.         }
  823.         return lck;
  824.     }

  826.     /**
  827.      * Make sure a ref is peeled and has the Storage PACKED. If the given ref
  828.      * has this attributes simply return it. Otherwise create a new peeled
  829.      * {@link ObjectIdRef} where Storage is set to PACKED.
  830.      *
  831.      * @param f
  832.      * @return a ref for Storage PACKED having the same name, id, peeledId as f
  833.      * @throws MissingObjectException
  834.      * @throws IOException
  835.      */
  836.     private Ref peeledPackedRef(Ref f)
  837.             throws MissingObjectException, IOException {
  838.         if (f.getStorage().isPacked() && f.isPeeled()) {
  839.             return f;
  840.         }
  841.         if (!f.isPeeled()) {
  842.             f = peel(f);
  843.         }
  844.         ObjectId peeledObjectId = f.getPeeledObjectId();
  845.         if (peeledObjectId != null) {
  846.             return new ObjectIdRef.PeeledTag(PACKED, f.getName(),
  847.                     f.getObjectId(), peeledObjectId);
  848.         }
  849.         return new ObjectIdRef.PeeledNonTag(PACKED, f.getName(),
  850.                 f.getObjectId());
  851.     }

  853.     void log(boolean force, RefUpdate update, String msg, boolean deref)
  854.             throws IOException {
  855.         newLogWriter(force).log(update, msg, deref);
  856.     }

  858.     private Ref resolve(final Ref ref, int depth, String prefix,
  859.             RefList<LooseRef> loose, RefList<Ref> packed) throws IOException {
  860.         if (ref.isSymbolic()) {
  861.             Ref dst = ref.getTarget();

  863.             if (MAX_SYMBOLIC_REF_DEPTH <= depth)
  864.                 return null; // claim it doesn't exist

  866.             // If the cached value can be assumed to be current due to a
  867.             // recent scan of the loose directory, use it.
  868.             if (loose != null && dst.getName().startsWith(prefix)) {
  869.                 int idx;
  870.                 if (0 <= (idx = loose.find(dst.getName())))
  871.                     dst = loose.get(idx);
  872.                 else if (0 <= (idx = packed.find(dst.getName())))
  873.                     dst = packed.get(idx);
  874.                 else
  875.                     return ref;
  876.             } else {
  877.                 dst = readRef(dst.getName(), packed);
  878.                 if (dst == null)
  879.                     return ref;
  880.             }

  882.             dst = resolve(dst, depth + 1, prefix, loose, packed);
  883.             if (dst == null)
  884.                 return null;
  885.             return new SymbolicRef(ref.getName(), dst);
  886.         }
  887.         return ref;
  888.     }

  890.     PackedRefList getPackedRefs() throws IOException {
  891.         boolean trustFolderStat = getRepository().getConfig().getBoolean(
  892.                 ConfigConstants.CONFIG_CORE_SECTION,
  893.                 ConfigConstants.CONFIG_KEY_TRUSTFOLDERSTAT, true);

  895.         final PackedRefList curList = packedRefs.get();
  896.         if (trustFolderStat && !curList.snapshot.isModified(packedRefsFile)) {
  897.             return curList;
  898.         }

  900.         final PackedRefList newList = readPackedRefs();
  901.         if (packedRefs.compareAndSet(curList, newList)
  902.                 && !curList.id.equals(newList.id)) {
  903.             modCnt.incrementAndGet();
  904.         }
  905.         return newList;
  906.     }

  908.     private PackedRefList readPackedRefs() throws IOException {
  909.         try {
  910.             PackedRefList result = FileUtils.readWithRetries(packedRefsFile,
  911.                     f -> {
  912.                         FileSnapshot snapshot = FileSnapshot.save(f);
  913.                         MessageDigest digest = Constants.newMessageDigest();
  914.                         try (BufferedReader br = new BufferedReader(
  915.                                 new InputStreamReader(
  916.                                         new DigestInputStream(
  917.                                                 new FileInputStream(f), digest),
  918.                                         UTF_8))) {
  919.                             return new PackedRefList(parsePackedRefs(br),
  920.                                     snapshot,
  921.                                     ObjectId.fromRaw(digest.digest()));
  922.                         }
  923.                     });
  924.             return result != null ? result : NO_PACKED_REFS;
  925.         } catch (IOException e) {
  926.             throw e;
  927.         } catch (Exception e) {
  928.             throw new IOException(MessageFormat
  929.                     .format(JGitText.get().cannotReadFile, packedRefsFile), e);
  930.         }
  931.     }

  933.     private RefList<Ref> parsePackedRefs(BufferedReader br)
  934.             throws IOException {
  935.         RefList.Builder<Ref> all = new RefList.Builder<>();
  936.         Ref last = null;
  937.         boolean peeled = false;
  938.         boolean needSort = false;

  940.         String p;
  941.         while ((p = br.readLine()) != null) {
  942.             if (p.charAt(0) == '#') {
  943.                 if (p.startsWith(PACKED_REFS_HEADER)) {
  944.                     p = p.substring(PACKED_REFS_HEADER.length());
  945.                     peeled = p.contains(PACKED_REFS_PEELED);
  946.                 }
  947.                 continue;
  948.             }

  950.             if (p.charAt(0) == '^') {
  951.                 if (last == null)
  952.                     throw new IOException(JGitText.get().peeledLineBeforeRef);

  954.                 ObjectId id = ObjectId.fromString(p.substring(1));
  955.                 last = new ObjectIdRef.PeeledTag(PACKED, last.getName(), last
  956.                         .getObjectId(), id);
  957.                 all.set(all.size() - 1, last);
  958.                 continue;
  959.             }

  961.             int sp = p.indexOf(' ');
  962.             if (sp < 0) {
  963.                 throw new IOException(MessageFormat.format(
  964.                         JGitText.get().packedRefsCorruptionDetected,
  965.                         packedRefsFile.getAbsolutePath()));
  966.             }
  967.             ObjectId id = ObjectId.fromString(p.substring(0, sp));
  968.             String name = copy(p, sp + 1, p.length());
  969.             ObjectIdRef cur;
  970.             if (peeled)
  971.                 cur = new ObjectIdRef.PeeledNonTag(PACKED, name, id);
  972.             else
  973.                 cur = new ObjectIdRef.Unpeeled(PACKED, name, id);
  974.             if (last != null && RefComparator.compareTo(last, cur) > 0)
  975.                 needSort = true;
  976.             all.add(cur);
  977.             last = cur;
  978.         }

  980.         if (needSort)
  981.             all.sort();
  982.         return all.toRefList();
  983.     }

  985.     private static String copy(String src, int off, int end) {
  986.         // Don't use substring since it could leave a reference to the much
  987.         // larger existing string. Force construction of a full new object.
  988.         return new StringBuilder(end - off).append(src, off, end).toString();
  989.     }

  991.     PackedRefList commitPackedRefs(final LockFile lck, final RefList<Ref> refs,
  992.             final PackedRefList oldPackedList, boolean changed)
  993.             throws IOException {
  994.         // Can't just return packedRefs.get() from this method; it might have been
  995.         // updated again after writePackedRefs() returns.
  996.         AtomicReference<PackedRefList> result = new AtomicReference<>();
  997.         new RefWriter(refs) {
  998.             @Override
  999.             protected void writeFile(String name, byte[] content)
  1000.                     throws IOException {
  1001.                 lck.setFSync(true);
  1002.                 lck.setNeedSnapshot(true);
  1003.                 try {
  1004.                     lck.write(content);
  1005.                 } catch (IOException ioe) {
  1006.                     throw new ObjectWritingException(MessageFormat.format(JGitText.get().unableToWrite, name), ioe);
  1007.                 }
  1008.                 try {
  1009.                     lck.waitForStatChange();
  1010.                 } catch (InterruptedException e) {
  1011.                     lck.unlock();
  1012.                     throw new ObjectWritingException(
  1013.                             MessageFormat.format(
  1014.                                     JGitText.get().interruptedWriting, name),
  1015.                             e);
  1016.                 }
  1017.                 if (!lck.commit())
  1018.                     throw new ObjectWritingException(MessageFormat.format(JGitText.get().unableToWrite, name));

  1020.                 byte[] digest = Constants.newMessageDigest().digest(content);
  1021.                 PackedRefList newPackedList = new PackedRefList(
  1022.                         refs, lck.getCommitSnapshot(), ObjectId.fromRaw(digest));

  1024.                 // This thread holds the file lock, so no other thread or process should
  1025.                 // be able to modify the packed-refs file on disk. If the list changed,
  1026.                 // it means something is very wrong, so throw an exception.
  1027.                 //
  1028.                 // However, we can't use a naive compareAndSet to check whether the
  1029.                 // update was successful, because another thread might _read_ the
  1030.                 // packed refs file that was written out by this thread while holding
  1031.                 // the lock, and update the packedRefs reference to point to that. So
  1032.                 // compare the actual contents instead.
  1033.                 PackedRefList afterUpdate = packedRefs.updateAndGet(
  1034.                         p -> p.id.equals(oldPackedList.id) ? newPackedList : p);
  1035.                 if (!afterUpdate.id.equals(newPackedList.id)) {
  1036.                     throw new ObjectWritingException(
  1037.                             MessageFormat.format(JGitText.get().unableToWrite, name));
  1038.                 }
  1039.                 if (changed) {
  1040.                     modCnt.incrementAndGet();
  1041.                 }
  1042.                 result.set(newPackedList);
  1043.             }
  1044.         }.writePackedRefs();
  1045.         return result.get();
  1046.     }

  1048.     private Ref readRef(String name, RefList<Ref> packed) throws IOException {
  1049.         final RefList<LooseRef> curList = looseRefs.get();
  1050.         final int idx = curList.find(name);
  1051.         if (0 <= idx) {
  1052.             final LooseRef o = curList.get(idx);
  1053.             final LooseRef n = scanRef(o, name);
  1054.             if (n == null) {
  1055.                 if (looseRefs.compareAndSet(curList, curList.remove(idx)))
  1056.                     modCnt.incrementAndGet();
  1057.                 return packed.get(name);
  1058.             }

  1060.             if (o == n)
  1061.                 return n;
  1062.             if (looseRefs.compareAndSet(curList, curList.set(idx, n)))
  1063.                 modCnt.incrementAndGet();
  1064.             return n;
  1065.         }

  1067.         final LooseRef n = scanRef(null, name);
  1068.         if (n == null)
  1069.             return packed.get(name);

  1071.         // check whether the found new ref is the an additional ref. These refs
  1072.         // should not go into looseRefs
  1073.         for (String additionalRefsName : additionalRefsNames) {
  1074.             if (name.equals(additionalRefsName)) {
  1075.                 return n;
  1076.             }
  1077.         }

  1079.         if (looseRefs.compareAndSet(curList, curList.add(idx, n)))
  1080.             modCnt.incrementAndGet();
  1081.         return n;
  1082.     }

  1084.     LooseRef scanRef(LooseRef ref, String name) throws IOException {
  1085.         final File path = fileFor(name);
  1086.         FileSnapshot currentSnapshot = null;

  1088.         if (ref != null) {
  1089.             currentSnapshot = ref.getSnapShot();
  1090.             if (!currentSnapshot.isModified(path))
  1091.                 return ref;
  1092.             name = ref.getName();
  1093.         }

  1095.         final int limit = 4096;

  1097.         class LooseItems {
  1098.             final FileSnapshot snapshot;

  1100.             final byte[] buf;

  1102.             LooseItems(FileSnapshot snapshot, byte[] buf) {
  1103.                 this.snapshot = snapshot;
  1104.                 this.buf = buf;
  1105.             }
  1106.         }
  1107.         LooseItems loose = null;
  1108.         try {
  1109.             loose = FileUtils.readWithRetries(path,
  1110.                     f -> new LooseItems(FileSnapshot.save(f),
  1111.                             IO.readSome(f, limit)));
  1112.         } catch (IOException e) {
  1113.             throw e;
  1114.         } catch (Exception e) {
  1115.             throw new IOException(
  1116.                     MessageFormat.format(JGitText.get().cannotReadFile, path),
  1117.                     e);
  1118.         }
  1119.         if (loose == null) {
  1120.             return null;
  1121.         }
  1122.         int n = loose.buf.length;
  1123.         if (n == 0)
  1124.             return null; // empty file; not a reference.

  1126.         if (isSymRef(loose.buf, n)) {
  1127.             if (n == limit)
  1128.                 return null; // possibly truncated ref

  1130.             // trim trailing whitespace
  1131.             while (0 < n && Character.isWhitespace(loose.buf[n - 1]))
  1132.                 n--;
  1133.             if (n < 6) {
  1134.                 String content = RawParseUtils.decode(loose.buf, 0, n);
  1135.                 throw new IOException(MessageFormat.format(JGitText.get().notARef, name, content));
  1136.             }
  1137.             final String target = RawParseUtils.decode(loose.buf, 5, n);
  1138.             if (ref != null && ref.isSymbolic()
  1139.                     && ref.getTarget().getName().equals(target)) {
  1140.                 assert(currentSnapshot != null);
  1141.                 currentSnapshot.setClean(loose.snapshot);
  1142.                 return ref;
  1143.             }
  1144.             return newSymbolicRef(loose.snapshot, name, target);
  1145.         }

  1147.         if (n < OBJECT_ID_STRING_LENGTH)
  1148.             return null; // impossibly short object identifier; not a reference.

  1150.         final ObjectId id;
  1151.         try {
  1152.             id = ObjectId.fromString(loose.buf, 0);
  1153.             if (ref != null && !ref.isSymbolic()
  1154.                     && id.equals(ref.getTarget().getObjectId())) {
  1155.                 assert(currentSnapshot != null);
  1156.                 currentSnapshot.setClean(loose.snapshot);
  1157.                 return ref;
  1158.             }

  1160.         } catch (IllegalArgumentException notRef) {
  1161.             while (0 < n && Character.isWhitespace(loose.buf[n - 1]))
  1162.                 n--;
  1163.             String content = RawParseUtils.decode(loose.buf, 0, n);

  1165.             throw new IOException(MessageFormat.format(JGitText.get().notARef,
  1166.                     name, content), notRef);
  1167.         }
  1168.         return new LooseUnpeeled(loose.snapshot, name, id);
  1169.     }

  1171.     private static boolean isSymRef(byte[] buf, int n) {
  1172.         if (n < 6)
  1173.             return false;
  1174.         return /**/buf[0] == 'r' //
  1175.                 && buf[1] == 'e' //
  1176.                 && buf[2] == 'f' //
  1177.                 && buf[3] == ':' //
  1178.                 && buf[4] == ' ';
  1179.     }

  1181.     /**
  1182.      * Detect if we are in a clone command execution
  1183.      *
  1184.      * @return {@code true} if we are currently cloning a repository
  1185.      * @throws IOException
  1186.      */
  1187.     boolean isInClone() throws IOException {
  1188.         return hasDanglingHead() && !packedRefsFile.exists() && !hasLooseRef();
  1189.     }

  1191.     private boolean hasDanglingHead() throws IOException {
  1192.         Ref head = exactRef(Constants.HEAD);
  1193.         if (head != null) {
  1194.             ObjectId id = head.getObjectId();
  1195.             return id == null || id.equals(ObjectId.zeroId());
  1196.         }
  1197.         return false;
  1198.     }

  1200.     private boolean hasLooseRef() throws IOException {
  1201.         try (Stream<Path> stream = Files.walk(refsDir.toPath())) {
  1202.             return stream.anyMatch(Files::isRegularFile);
  1203.         }
  1204.     }

  1206.     /** If the parent should fire listeners, fires them. */
  1207.     void fireRefsChanged() {
  1208.         final int last = lastNotifiedModCnt.get();
  1209.         final int curr = modCnt.get();
  1210.         if (last != curr && lastNotifiedModCnt.compareAndSet(last, curr) && last != 0)
  1211.             parent.fireEvent(new RefsChangedEvent());
  1212.     }

  1214.     /**
  1215.      * Create a reference update to write a temporary reference.
  1216.      *
  1217.      * @return an update for a new temporary reference.
  1218.      * @throws IOException
  1219.      *             a temporary name cannot be allocated.
  1220.      */
  1221.     RefDirectoryUpdate newTemporaryUpdate() throws IOException {
  1222.         File tmp = File.createTempFile("renamed_", "_ref", refsDir); //$NON-NLS-1$ //$NON-NLS-2$
  1223.         String name = Constants.R_REFS + tmp.getName();
  1224.         Ref ref = new ObjectIdRef.Unpeeled(NEW, name, null);
  1225.         return new RefDirectoryUpdate(this, ref);
  1226.     }

  1228.     /**
  1229.      * Locate the file on disk for a single reference name.
  1230.      *
  1231.      * @param name
  1232.      *            name of the ref, relative to the Git repository top level
  1233.      *            directory (so typically starts with refs/).
  1234.      * @return the loose file location.
  1235.      */
  1236.     File fileFor(String name) {
  1237.         if (name.startsWith(R_REFS)) {
  1238.             name = name.substring(R_REFS.length());
  1239.             return new File(refsDir, name);
  1240.         }
  1241.         return new File(gitDir, name);
  1242.     }

  1244.     static int levelsIn(String name) {
  1245.         int count = 0;
  1246.         for (int p = name.indexOf('/'); p >= 0; p = name.indexOf('/', p + 1))
  1247.             count++;
  1248.         return count;
  1249.     }

  1251.     static void delete(File file, int depth) throws IOException {
  1252.         delete(file, depth, null);
  1253.     }

  1255.     private static void delete(File file, int depth, LockFile rLck)
  1256.             throws IOException {
  1257.         if (!file.delete() && file.isFile()) {
  1258.             throw new IOException(MessageFormat.format(
  1259.                     JGitText.get().fileCannotBeDeleted, file));
  1260.         }

  1262.         if (rLck != null) {
  1263.             rLck.unlock(); // otherwise cannot delete dir below
  1264.         }
  1265.         File dir = file.getParentFile();
  1266.         for (int i = 0; i < depth; ++i) {
  1267.             try {
  1268.                 Files.deleteIfExists(dir.toPath());
  1269.             } catch (DirectoryNotEmptyException e) {
  1270.                 // Don't log; normal case when there are other refs with the
  1271.                 // same prefix
  1272.                 break;
  1273.             } catch (IOException e) {
  1274.                 LOG.warn(MessageFormat.format(JGitText.get().unableToRemovePath,
  1275.                         dir), e);
  1276.                 break;
  1277.             }
  1278.             dir = dir.getParentFile();
  1279.         }
  1280.     }

  1282.     /**
  1283.      * Get times to sleep while retrying a possibly contentious operation.
  1284.      * <p>
  1285.      * For retrying an operation that might have high contention, such as locking
  1286.      * the {@code packed-refs} file, the caller may implement a retry loop using
  1287.      * the returned values:
  1288.      *
  1289.      * <pre>
  1290.      * for (int toSleepMs : getRetrySleepMs()) {
  1291.      *   sleep(toSleepMs);
  1292.      *   if (isSuccessful(doSomething())) {
  1293.      *     return success;
  1294.      *   }
  1295.      * }
  1296.      * return failure;
  1297.      * </pre>
  1298.      *
  1299.      * The first value in the returned iterable is 0, and the caller should treat
  1300.      * a fully-consumed iterator as a timeout.
  1301.      *
  1302.      * @return iterable of times, in milliseconds, that the caller should sleep
  1303.      *         before attempting an operation.
  1304.      */
  1305.     Iterable<Integer> getRetrySleepMs() {
  1306.         return retrySleepMs;
  1307.     }

  1309.     void setRetrySleepMs(List<Integer> retrySleepMs) {
  1310.         if (retrySleepMs == null || retrySleepMs.isEmpty()
  1311.                 || retrySleepMs.get(0).intValue() != 0) {
  1312.             throw new IllegalArgumentException();
  1313.         }
  1314.         this.retrySleepMs = retrySleepMs;
  1315.     }

  1317.     /**
  1318.      * Sleep with {@link Thread#sleep(long)}, converting {@link
  1319.      * InterruptedException} to {@link InterruptedIOException}.
  1320.      *
  1321.      * @param ms
  1322.      *            time to sleep, in milliseconds; zero or negative is a no-op.
  1323.      * @throws InterruptedIOException
  1324.      *             if sleeping was interrupted.
  1325.      */
  1326.     static void sleep(long ms) throws InterruptedIOException {
  1327.         if (ms <= 0) {
  1328.             return;
  1329.         }
  1330.         try {
  1331.             Thread.sleep(ms);
  1332.         } catch (InterruptedException e) {
  1333.             InterruptedIOException ie = new InterruptedIOException();
  1334.             ie.initCause(e);
  1335.             throw ie;
  1336.         }
  1337.     }

  1339.     static class PackedRefList extends RefList<Ref> {

  1341.         private final FileSnapshot snapshot;

  1343.         private final ObjectId id;

  1345.         private PackedRefList(RefList<Ref> src, FileSnapshot s, ObjectId i) {
  1346.             super(src);
  1347.             snapshot = s;
  1348.             id = i;
  1349.         }
  1350.     }

  1352.     private static final PackedRefList NO_PACKED_REFS = new PackedRefList(
  1353.             RefList.emptyList(), FileSnapshot.MISSING_FILE,
  1354.             ObjectId.zeroId());

  1356.     private static LooseSymbolicRef newSymbolicRef(FileSnapshot snapshot,
  1357.             String name, String target) {
  1358.         Ref dst = new ObjectIdRef.Unpeeled(NEW, target, null);
  1359.         return new LooseSymbolicRef(snapshot, name, dst);
  1360.     }

  1362.     private static interface LooseRef extends Ref {
  1363.         FileSnapshot getSnapShot();

  1365.         LooseRef peel(ObjectIdRef newLeaf);
  1366.     }

  1368.     private static final class LoosePeeledTag extends ObjectIdRef.PeeledTag
  1369.             implements LooseRef {
  1370.         private final FileSnapshot snapShot;

  1372.         LoosePeeledTag(FileSnapshot snapshot, @NonNull String refName,
  1373.                 @NonNull ObjectId id, @NonNull ObjectId p) {
  1374.             super(LOOSE, refName, id, p);
  1375.             this.snapShot = snapshot;
  1376.         }

  1378.         @Override
  1379.         public FileSnapshot getSnapShot() {
  1380.             return snapShot;
  1381.         }

  1383.         @Override
  1384.         public LooseRef peel(ObjectIdRef newLeaf) {
  1385.             return this;
  1386.         }
  1387.     }

  1389.     private static final class LooseNonTag extends ObjectIdRef.PeeledNonTag
  1390.             implements LooseRef {
  1391.         private final FileSnapshot snapShot;

  1393.         LooseNonTag(FileSnapshot snapshot, @NonNull String refName,
  1394.                 @NonNull ObjectId id) {
  1395.             super(LOOSE, refName, id);
  1396.             this.snapShot = snapshot;
  1397.         }

  1399.         @Override
  1400.         public FileSnapshot getSnapShot() {
  1401.             return snapShot;
  1402.         }

  1404.         @Override
  1405.         public LooseRef peel(ObjectIdRef newLeaf) {
  1406.             return this;
  1407.         }
  1408.     }

  1410.     private static final class LooseUnpeeled extends ObjectIdRef.Unpeeled
  1411.             implements LooseRef {
  1412.         private FileSnapshot snapShot;

  1414.         LooseUnpeeled(FileSnapshot snapShot, @NonNull String refName,
  1415.                 @NonNull ObjectId id) {
  1416.             super(LOOSE, refName, id);
  1417.             this.snapShot = snapShot;
  1418.         }

  1420.         @Override
  1421.         public FileSnapshot getSnapShot() {
  1422.             return snapShot;
  1423.         }

  1425.         @NonNull
  1426.         @Override
  1427.         public ObjectId getObjectId() {
  1428.             ObjectId id = super.getObjectId();
  1429.             assert id != null; // checked in constructor
  1430.             return id;
  1431.         }

  1433.         @Override
  1434.         public LooseRef peel(ObjectIdRef newLeaf) {
  1435.             ObjectId peeledObjectId = newLeaf.getPeeledObjectId();
  1436.             ObjectId objectId = getObjectId();
  1437.             if (peeledObjectId != null) {
  1438.                 return new LoosePeeledTag(snapShot, getName(),
  1439.                         objectId, peeledObjectId);
  1440.             }
  1441.             return new LooseNonTag(snapShot, getName(), objectId);
  1442.         }
  1443.     }

  1445.     private static final class LooseSymbolicRef extends SymbolicRef implements
  1446.             LooseRef {
  1447.         private final FileSnapshot snapShot;

  1449.         LooseSymbolicRef(FileSnapshot snapshot, @NonNull String refName,
  1450.                 @NonNull Ref target) {
  1451.             super(refName, target);
  1452.             this.snapShot = snapshot;
  1453.         }

  1455.         @Override
  1456.         public FileSnapshot getSnapShot() {
  1457.             return snapShot;
  1458.         }

  1460.         @Override
  1461.         public LooseRef peel(ObjectIdRef newLeaf) {
  1462.             // We should never try to peel the symbolic references.
  1463.             throw new UnsupportedOperationException();
  1464.         }
  1465.     }
  1466. }
Created with JaCoCo 0.8.7.202105040129