blob: f198782d203fcdf2d3232e18cf4ba0b4528e6fdb [file]
/*
* Copyright (C) 2008, Charles O'Farrell <charleso@charleso.org>
* Copyright (C) 2009-2010, Google Inc.
* Copyright (C) 2009, Robin Rosenberg <robin.rosenberg@dewire.com>
* Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> and others
* Copyright (C) 2026, Nvidia
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.lib;
import static org.eclipse.jgit.lib.Constants.R_TAGS;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumSet;
import org.eclipse.jgit.internal.storage.file.RefDirectory;
import org.eclipse.jgit.util.RefList;
/**
* Writes out refs to {@link org.eclipse.jgit.lib.Constants#PACKED_REFS} file by
* computing and applying all the missing traits for optimized reads.
*
* @since 7.7
*/
public abstract class PackedRefsWriter {
/** Refs to be written. */
protected Collection<Ref> refs;
/** Traits that are applicable to the refs. */
protected final EnumSet<PackedRefsTrait> traits;
/**
* <p>
* Constructor for PackedRefsWriter.
* </p>
*
* @param refs
* the complete set of references. This should have been computed
* by applying updates to the advertised refs already discovered.
* @param traits
* traits that are applicable to the refs. If any traits are
* missing, they would be applied before writing, but the
* specified traits are not re-computed/checked.
* @param refDb
* refDb where the packed-refs file should be written.
*
* @throws IOException
* if it is not able to peel any of the tags.
* @since 7.7
*/
public PackedRefsWriter(Collection<Ref> refs,
EnumSet<PackedRefsTrait> traits, RefDatabase refDb)
throws IOException {
this(refs, traits);
applyMissingTraits(refDb);
}
/**
* <p>
* Constructor for PackedRefsWriter.
* </p>
*
* <p>
* Stores the provided refs and traits without applying any missing traits.
* Intended for use by subclasses that manage trait application themselves.
* </p>
*
* @param refs
* the complete set of references. This should have been computed
* by applying updates to the advertised refs already discovered.
* @param traits
* traits that are applicable to the refs.
*/
protected PackedRefsWriter(Collection<Ref> refs,
EnumSet<PackedRefsTrait> traits) {
this.refs = refs;
this.traits = traits;
}
/**
* Rebuild the {@link org.eclipse.jgit.lib.Constants#INFO_REFS}.
* <p>
* This method rebuilds the contents of the
* {@link org.eclipse.jgit.lib.Constants#INFO_REFS} file to match the passed
* list of references.
*
* @throws java.io.IOException
* writing is not supported, or attempting to write the file
* failed, possibly due to permissions or remote disk full, etc.
*/
public void writeInfoRefs() throws IOException {
final StringWriter w = new StringWriter();
final char[] tmp = new char[Constants.OBJECT_ID_STRING_LENGTH];
for (Ref r : refs) {
if (Constants.HEAD.equals(r.getName())) {
// Historically HEAD has never been published through
// the INFO_REFS file. This is a mistake, but its the
// way things are.
//
continue;
}
ObjectId objectId = r.getObjectId();
if (objectId == null) {
// Symrefs to unborn branches aren't advertised in the info/refs
// file.
continue;
}
objectId.copyTo(tmp, w);
w.write('\t');
w.write(r.getName());
w.write('\n');
ObjectId peeledObjectId = r.getPeeledObjectId();
if (peeledObjectId != null) {
peeledObjectId.copyTo(tmp, w);
w.write('\t');
w.write(r.getName());
w.write("^{}\n"); //$NON-NLS-1$
}
}
writeFile(Constants.INFO_REFS, Constants.encode(w.toString()));
}
/**
* Rebuild the {@link org.eclipse.jgit.lib.Constants#PACKED_REFS} file.
* <p>
* This method rebuilds the contents of the
* {@link org.eclipse.jgit.lib.Constants#PACKED_REFS} file to match the
* passed list of references, including only those refs that have a storage
* type of {@link org.eclipse.jgit.lib.Ref.Storage#PACKED}.
*
* @throws java.io.IOException
* writing is not supported, or attempting to write the file
* failed, possibly due to permissions or remote disk full, etc.
*/
public void writePackedRefs() throws IOException {
final StringWriter w = new StringWriter();
w.write(RefDirectory.PACKED_REFS_HEADER);
for (PackedRefsTrait t : traits) {
w.write(t.value());
}
w.write('\n');
final char[] tmp = new char[Constants.OBJECT_ID_STRING_LENGTH];
for (Ref r : refs) {
if (r.getStorage() != Ref.Storage.PACKED)
continue;
ObjectId objectId = r.getObjectId();
if (objectId == null) {
// A packed ref cannot be a symref, let alone a symref
// to an unborn branch.
throw new NullPointerException();
}
objectId.copyTo(tmp, w);
w.write(' ');
w.write(r.getName());
w.write('\n');
ObjectId peeledObjectId = r.getPeeledObjectId();
if (peeledObjectId != null) {
w.write('^');
peeledObjectId.copyTo(tmp, w);
w.write('\n');
}
}
writeFile(Constants.PACKED_REFS, Constants.encode(w.toString()));
}
/**
* Access the new refs after all the necessary traits were applied.
*
* @return refs with all the traits applied
*/
public RefList<Ref> asRefList() {
RefList.Builder<Ref> builder = new RefList.Builder<>(this.refs.size());
for (Ref each : refs) {
builder.add(each);
}
return builder.toRefList();
}
/**
* Handles actual writing of ref files to the git repository, which may
* differ slightly depending on the destination and transport.
*
* @param file
* path to ref file.
* @param content
* byte content of file to be written.
* @throws java.io.IOException
* if an IO error occurred
*/
protected abstract void writeFile(String file, byte[] content)
throws IOException;
private void applyMissingTraits(RefDatabase refDb) throws IOException {
if (!traits.contains(PackedRefsTrait.SORTED)) {
refs = RefComparator.sort(refs);
traits.add(PackedRefsTrait.SORTED);
}
if (traits.contains(PackedRefsTrait.FULLY_PEELED)) {
// fully-peeled implies peeled.
traits.add(PackedRefsTrait.PEELED);
return;
}
Collection<Ref> peeledRefs = new ArrayList<>();
for (Ref ref : refs) {
if (ref.isPeeled() || (traits.contains(PackedRefsTrait.PEELED)
&& ref.getName().startsWith(R_TAGS))) {
// trust refs/tags/... when caller provides peeled trait.
peeledRefs.add(ref);
} else {
peeledRefs.add(refDb.peel(ref));
}
}
refs = peeledRefs;
traits.add(PackedRefsTrait.PEELED);
traits.add(PackedRefsTrait.FULLY_PEELED);
}
}