FileRepository.java
/*
* Copyright (C) 2007, Dave Watson <dwatson@mimvista.com>
* Copyright (C) 2008-2010, Google Inc.
* Copyright (C) 2006-2010, Robin Rosenberg <robin.rosenberg@dewire.com>
* Copyright (C) 2006-2008, Shawn O. Pearce <spearce@spearce.org> and others
*
* 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.internal.storage.file;
import static java.util.stream.Collectors.toList;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.MessageFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Set;
import org.eclipse.jgit.annotations.Nullable;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.attributes.AttributesNode;
import org.eclipse.jgit.attributes.AttributesNodeProvider;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.events.IndexChangedEvent;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.internal.storage.file.ObjectDirectory.AlternateHandle;
import org.eclipse.jgit.internal.storage.file.ObjectDirectory.AlternateRepository;
import org.eclipse.jgit.lib.BaseRepositoryBuilder;
import org.eclipse.jgit.lib.BatchRefUpdate;
import org.eclipse.jgit.lib.ConfigConstants;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.CoreConfig.HideDotFiles;
import org.eclipse.jgit.lib.CoreConfig.SymLinks;
import org.eclipse.jgit.lib.NullProgressMonitor;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ProgressMonitor;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefDatabase;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.ReflogEntry;
import org.eclipse.jgit.lib.ReflogReader;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.storage.file.FileBasedConfig;
import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
import org.eclipse.jgit.storage.pack.PackConfig;
import org.eclipse.jgit.transport.ReceiveCommand;
import org.eclipse.jgit.util.FileUtils;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.RawParseUtils;
import org.eclipse.jgit.util.StringUtils;
import org.eclipse.jgit.util.SystemReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Represents a Git repository. A repository holds all objects and refs used for
* managing source code (could by any type of file, but source code is what
* SCM's are typically used for).
*
* In Git terms all data is stored in GIT_DIR, typically a directory called
* .git. A work tree is maintained unless the repository is a bare repository.
* Typically the .git directory is located at the root of the work dir.
*
* <ul>
* <li>GIT_DIR
* <ul>
* <li>objects/ - objects</li>
* <li>refs/ - tags and heads</li>
* <li>config - configuration</li>
* <li>info/ - more configurations</li>
* </ul>
* </li>
* </ul>
* <p>
* This class is thread-safe.
* <p>
* This implementation only handles a subtly undocumented subset of git features.
*/
public class FileRepository extends Repository {
private static final Logger LOG = LoggerFactory
.getLogger(FileRepository.class);
private static final String UNNAMED = "Unnamed repository; edit this file to name it for gitweb."; //$NON-NLS-1$
private final FileBasedConfig repoConfig;
private RefDatabase refs;
private final ObjectDirectory objectDatabase;
private final Object snapshotLock = new Object();
// protected by snapshotLock
private FileSnapshot snapshot;
/**
* Construct a representation of a Git repository.
* <p>
* The work tree, object directory, alternate object directories and index
* file locations are deduced from the given git directory and the default
* rules by running
* {@link org.eclipse.jgit.storage.file.FileRepositoryBuilder}. This
* constructor is the same as saying:
*
* <pre>
* new FileRepositoryBuilder().setGitDir(gitDir).build()
* </pre>
*
* @param gitDir
* GIT_DIR (the location of the repository metadata).
* @throws java.io.IOException
* the repository appears to already exist but cannot be
* accessed.
* @see FileRepositoryBuilder
*/
public FileRepository(File gitDir) throws IOException {
this(new FileRepositoryBuilder().setGitDir(gitDir).setup());
}
/**
* A convenience API for {@link #FileRepository(File)}.
*
* @param gitDir
* GIT_DIR (the location of the repository metadata).
* @throws java.io.IOException
* the repository appears to already exist but cannot be
* accessed.
* @see FileRepositoryBuilder
*/
public FileRepository(String gitDir) throws IOException {
this(new File(gitDir));
}
/**
* Create a repository using the local file system.
*
* @param options
* description of the repository's important paths.
* @throws java.io.IOException
* the user configuration file or repository configuration file
* cannot be accessed.
*/
public FileRepository(BaseRepositoryBuilder options) throws IOException {
super(options);
StoredConfig userConfig = null;
try {
userConfig = SystemReader.getInstance().getUserConfig();
} catch (ConfigInvalidException e) {
LOG.error(e.getMessage(), e);
throw new IOException(e.getMessage(), e);
}
repoConfig = new FileBasedConfig(userConfig, getFS().resolve(
getDirectory(), Constants.CONFIG),
getFS());
loadRepoConfig();
repoConfig.addChangeListener(this::fireEvent);
final long repositoryFormatVersion = getConfig().getLong(
ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_REPO_FORMAT_VERSION, 0);
String reftype = repoConfig.getString(
ConfigConstants.CONFIG_EXTENSIONS_SECTION, null,
ConfigConstants.CONFIG_KEY_REF_STORAGE);
if (repositoryFormatVersion >= 1 && reftype != null) {
if (StringUtils.equalsIgnoreCase(reftype,
ConfigConstants.CONFIG_REF_STORAGE_REFTABLE)) {
refs = new FileReftableDatabase(this);
} else {
throw new IOException(JGitText.get().unknownRepositoryFormat);
}
} else {
refs = new RefDirectory(this);
}
objectDatabase = new ObjectDirectory(repoConfig, //
options.getObjectDirectory(), //
options.getAlternateObjectDirectories(), //
getFS(), //
new File(getDirectory(), Constants.SHALLOW));
if (objectDatabase.exists()) {
if (repositoryFormatVersion > 1)
throw new IOException(MessageFormat.format(
JGitText.get().unknownRepositoryFormat2,
Long.valueOf(repositoryFormatVersion)));
}
if (!isBare()) {
snapshot = FileSnapshot.save(getIndexFile());
}
}
private void loadRepoConfig() throws IOException {
try {
repoConfig.load();
} catch (ConfigInvalidException e) {
throw new IOException(JGitText.get().unknownRepositoryFormat, e);
}
}
/**
* {@inheritDoc}
* <p>
* Create a new Git repository initializing the necessary files and
* directories.
*/
@Override
public void create(boolean bare) throws IOException {
final FileBasedConfig cfg = getConfig();
if (cfg.getFile().exists()) {
throw new IllegalStateException(MessageFormat.format(
JGitText.get().repositoryAlreadyExists, getDirectory()));
}
FileUtils.mkdirs(getDirectory(), true);
HideDotFiles hideDotFiles = getConfig().getEnum(
ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_HIDEDOTFILES,
HideDotFiles.DOTGITONLY);
if (hideDotFiles != HideDotFiles.FALSE && !isBare()
&& getDirectory().getName().startsWith(".")) //$NON-NLS-1$
getFS().setHidden(getDirectory(), true);
refs.create();
objectDatabase.create();
FileUtils.mkdir(new File(getDirectory(), "branches")); //$NON-NLS-1$
FileUtils.mkdir(new File(getDirectory(), "hooks")); //$NON-NLS-1$
RefUpdate head = updateRef(Constants.HEAD);
head.disableRefLog();
head.link(Constants.R_HEADS + getInitialBranch());
final boolean fileMode;
if (getFS().supportsExecute()) {
File tmp = File.createTempFile("try", "execute", getDirectory()); //$NON-NLS-1$ //$NON-NLS-2$
getFS().setExecute(tmp, true);
final boolean on = getFS().canExecute(tmp);
getFS().setExecute(tmp, false);
final boolean off = getFS().canExecute(tmp);
FileUtils.delete(tmp);
fileMode = on && !off;
} else {
fileMode = false;
}
SymLinks symLinks = SymLinks.FALSE;
if (getFS().supportsSymlinks()) {
File tmp = new File(getDirectory(), "tmplink"); //$NON-NLS-1$
try {
getFS().createSymLink(tmp, "target"); //$NON-NLS-1$
symLinks = null;
FileUtils.delete(tmp);
} catch (IOException e) {
// Normally a java.nio.file.FileSystemException
}
}
if (symLinks != null)
cfg.setString(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_SYMLINKS, symLinks.name()
.toLowerCase(Locale.ROOT));
cfg.setInt(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_REPO_FORMAT_VERSION, 0);
cfg.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_FILEMODE, fileMode);
if (bare)
cfg.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_BARE, true);
cfg.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_LOGALLREFUPDATES, !bare);
if (SystemReader.getInstance().isMacOS())
// Java has no other way
cfg.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_PRECOMPOSEUNICODE, true);
if (!bare) {
File workTree = getWorkTree();
if (!getDirectory().getParentFile().equals(workTree)) {
cfg.setString(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_WORKTREE, getWorkTree()
.getAbsolutePath());
LockFile dotGitLockFile = new LockFile(new File(workTree,
Constants.DOT_GIT));
try {
if (dotGitLockFile.lock()) {
dotGitLockFile.write(Constants.encode(Constants.GITDIR
+ getDirectory().getAbsolutePath()));
dotGitLockFile.commit();
}
} finally {
dotGitLockFile.unlock();
}
}
}
cfg.save();
}
/**
* Get the directory containing the objects owned by this repository
*
* @return the directory containing the objects owned by this repository.
*/
public File getObjectsDirectory() {
return objectDatabase.getDirectory();
}
/** {@inheritDoc} */
@Override
public ObjectDirectory getObjectDatabase() {
return objectDatabase;
}
/** {@inheritDoc} */
@Override
public RefDatabase getRefDatabase() {
return refs;
}
/** {@inheritDoc} */
@Override
public String getIdentifier() {
File directory = getDirectory();
if (directory != null) {
return directory.getPath();
}
throw new IllegalStateException();
}
/** {@inheritDoc} */
@Override
public FileBasedConfig getConfig() {
try {
SystemReader.getInstance().getUserConfig();
if (repoConfig.isOutdated()) {
loadRepoConfig();
}
} catch (IOException | ConfigInvalidException e) {
throw new RuntimeException(e);
}
return repoConfig;
}
/** {@inheritDoc} */
@Override
@Nullable
public String getGitwebDescription() throws IOException {
String d;
try {
d = RawParseUtils.decode(IO.readFully(descriptionFile()));
} catch (FileNotFoundException err) {
return null;
}
if (d != null) {
d = d.trim();
if (d.isEmpty() || UNNAMED.equals(d)) {
return null;
}
}
return d;
}
/** {@inheritDoc} */
@Override
public void setGitwebDescription(@Nullable String description)
throws IOException {
String old = getGitwebDescription();
if (Objects.equals(old, description)) {
return;
}
File path = descriptionFile();
LockFile lock = new LockFile(path);
if (!lock.lock()) {
throw new IOException(MessageFormat.format(JGitText.get().lockError,
path.getAbsolutePath()));
}
try {
String d = description;
if (d != null) {
d = d.trim();
if (!d.isEmpty()) {
d += '\n';
}
} else {
d = ""; //$NON-NLS-1$
}
lock.write(Constants.encode(d));
lock.commit();
} finally {
lock.unlock();
}
}
private File descriptionFile() {
return new File(getDirectory(), "description"); //$NON-NLS-1$
}
/**
* {@inheritDoc}
* <p>
* Objects known to exist but not expressed by {@code #getAllRefs()}.
* <p>
* When a repository borrows objects from another repository, it can
* advertise that it safely has that other repository's references, without
* exposing any other details about the other repository. This may help a
* client trying to push changes avoid pushing more than it needs to.
*
* @throws IOException
*/
@Override
public Set<ObjectId> getAdditionalHaves() throws IOException {
return getAdditionalHaves(null);
}
/**
* Objects known to exist but not expressed by {@code #getAllRefs()}.
* <p>
* When a repository borrows objects from another repository, it can
* advertise that it safely has that other repository's references, without
* exposing any other details about the other repository. This may help a
* client trying to push changes avoid pushing more than it needs to.
*
* @param skips
* Set of AlternateHandle Ids already seen
*
* @return unmodifiable collection of other known objects.
* @throws IOException
* if getting refs hits an IO error
*/
private Set<ObjectId> getAdditionalHaves(Set<AlternateHandle.Id> skips)
throws IOException {
HashSet<ObjectId> r = new HashSet<>();
skips = objectDatabase.addMe(skips);
for (AlternateHandle d : objectDatabase.myAlternates()) {
if (d instanceof AlternateRepository && !skips.contains(d.getId())) {
FileRepository repo;
repo = ((AlternateRepository) d).repository;
for (Ref ref : repo.getRefDatabase().getRefs()) {
if (ref.getObjectId() != null)
r.add(ref.getObjectId());
if (ref.getPeeledObjectId() != null)
r.add(ref.getPeeledObjectId());
}
r.addAll(repo.getAdditionalHaves(skips));
}
}
return r;
}
/**
* Add a single existing pack to the list of available pack files.
*
* @param pack
* path of the pack file to open.
* @throws java.io.IOException
* index file could not be opened, read, or is not recognized as
* a Git pack file index.
*/
public void openPack(File pack) throws IOException {
objectDatabase.openPack(pack);
}
/** {@inheritDoc} */
@Override
public void scanForRepoChanges() throws IOException {
getRefDatabase().getRefs(); // This will look for changes to refs
detectIndexChanges();
}
/** Detect index changes. */
private void detectIndexChanges() {
if (isBare()) {
return;
}
File indexFile = getIndexFile();
synchronized (snapshotLock) {
if (snapshot == null) {
snapshot = FileSnapshot.save(indexFile);
return;
}
if (!snapshot.isModified(indexFile)) {
return;
}
}
notifyIndexChanged(false);
}
/** {@inheritDoc} */
@Override
public void notifyIndexChanged(boolean internal) {
synchronized (snapshotLock) {
snapshot = FileSnapshot.save(getIndexFile());
}
fireEvent(new IndexChangedEvent(internal));
}
/** {@inheritDoc} */
@Override
public ReflogReader getReflogReader(String refName) throws IOException {
if (refs instanceof FileReftableDatabase) {
// Cannot use findRef: reftable stores log data for deleted or renamed
// branches.
return ((FileReftableDatabase)refs).getReflogReader(refName);
}
// TODO: use exactRef here, which offers more predictable and therefore preferable
// behavior.
Ref ref = findRef(refName);
if (ref == null) {
return null;
}
return new ReflogReaderImpl(this, ref.getName());
}
/** {@inheritDoc} */
@Override
public AttributesNodeProvider createAttributesNodeProvider() {
return new AttributesNodeProviderImpl(this);
}
/**
* Implementation a {@link AttributesNodeProvider} for a
* {@link FileRepository}.
*
* @author <a href="mailto:arthur.daussy@obeo.fr">Arthur Daussy</a>
*
*/
static class AttributesNodeProviderImpl implements
AttributesNodeProvider {
private AttributesNode infoAttributesNode;
private AttributesNode globalAttributesNode;
/**
* Constructor.
*
* @param repo
* {@link Repository} that will provide the attribute nodes.
*/
protected AttributesNodeProviderImpl(Repository repo) {
infoAttributesNode = new InfoAttributesNode(repo);
globalAttributesNode = new GlobalAttributesNode(repo);
}
@Override
public AttributesNode getInfoAttributesNode() throws IOException {
if (infoAttributesNode instanceof InfoAttributesNode)
infoAttributesNode = ((InfoAttributesNode) infoAttributesNode)
.load();
return infoAttributesNode;
}
@Override
public AttributesNode getGlobalAttributesNode() throws IOException {
if (globalAttributesNode instanceof GlobalAttributesNode)
globalAttributesNode = ((GlobalAttributesNode) globalAttributesNode)
.load();
return globalAttributesNode;
}
static void loadRulesFromFile(AttributesNode r, File attrs)
throws FileNotFoundException, IOException {
if (attrs.exists()) {
try (FileInputStream in = new FileInputStream(attrs)) {
r.parse(in);
}
}
}
}
private boolean shouldAutoDetach() {
return getConfig().getBoolean(ConfigConstants.CONFIG_GC_SECTION,
ConfigConstants.CONFIG_KEY_AUTODETACH, true);
}
/** {@inheritDoc} */
@Override
public void autoGC(ProgressMonitor monitor) {
GC gc = new GC(this);
gc.setPackConfig(new PackConfig(this));
gc.setProgressMonitor(monitor);
gc.setAuto(true);
gc.setBackground(shouldAutoDetach());
try {
gc.gc();
} catch (ParseException | IOException e) {
throw new JGitInternalException(JGitText.get().gcFailed, e);
}
}
/**
* Converts the RefDatabase from reftable to RefDirectory. This operation is
* not atomic.
*
* @param writeLogs
* whether to write reflogs
* @param backup
* whether to rename or delete the old storage files. If set to
* {@code true}, the reftable list is left in {@code refs.old},
* and the {@code reftable/} dir is left alone. If set to
* {@code false}, the {@code reftable/} dir is removed, and
* {@code refs} file is removed.
* @throws IOException
* on IO problem
*/
void convertToPackedRefs(boolean writeLogs, boolean backup) throws IOException {
List<Ref> all = refs.getRefs();
File packedRefs = new File(getDirectory(), Constants.PACKED_REFS);
if (packedRefs.exists()) {
throw new IOException(MessageFormat.format(JGitText.get().fileAlreadyExists,
packedRefs.getName()));
}
File refsFile = new File(getDirectory(), "refs"); //$NON-NLS-1$
File refsHeadsFile = new File(refsFile, "heads");//$NON-NLS-1$
File headFile = new File(getDirectory(), Constants.HEAD);
FileReftableDatabase oldDb = (FileReftableDatabase) refs;
// Remove the dummy files that ensure compatibility with older git
// versions (see convertToReftable). First make room for refs/heads/
refsHeadsFile.delete();
// RefDirectory wants to create the refs/ directory from scratch, so
// remove that too.
refsFile.delete();
// remove HEAD so its previous invalid value doesn't cause issues.
headFile.delete();
// This is not atomic, but there is no way to instantiate a RefDirectory
// that is disconnected from the current repo.
RefDirectory refDir = new RefDirectory(this);
refs = refDir;
refs.create();
ReflogWriter logWriter = refDir.newLogWriter(true);
List<Ref> symrefs = new ArrayList<>();
BatchRefUpdate bru = refs.newBatchUpdate();
for (Ref r : all) {
if (r.isSymbolic()) {
symrefs.add(r);
} else {
bru.addCommand(new ReceiveCommand(ObjectId.zeroId(),
r.getObjectId(), r.getName()));
}
if (writeLogs) {
List<ReflogEntry> logs = oldDb.getReflogReader(r.getName())
.getReverseEntries();
Collections.reverse(logs);
for (ReflogEntry e : logs) {
logWriter.log(r.getName(), e);
}
}
}
try (RevWalk rw = new RevWalk(this)) {
bru.execute(rw, NullProgressMonitor.INSTANCE);
}
List<String> failed = new ArrayList<>();
for (ReceiveCommand cmd : bru.getCommands()) {
if (cmd.getResult() != ReceiveCommand.Result.OK) {
failed.add(cmd.getRefName() + ": " + cmd.getResult()); //$NON-NLS-1$
}
}
if (!failed.isEmpty()) {
throw new IOException(String.format("%s: %s", //$NON-NLS-1$
JGitText.get().failedToConvert,
StringUtils.join(failed, ", "))); //$NON-NLS-1$
}
for (Ref s : symrefs) {
RefUpdate up = refs.newUpdate(s.getName(), false);
up.setForceUpdate(true);
RefUpdate.Result res = up.link(s.getTarget().getName());
if (res != RefUpdate.Result.NEW
&& res != RefUpdate.Result.NO_CHANGE) {
throw new IOException(
String.format("ref %s: %s", s.getName(), res)); //$NON-NLS-1$
}
}
if (!backup) {
File reftableDir = new File(getDirectory(), Constants.REFTABLE);
FileUtils.delete(reftableDir,
FileUtils.RECURSIVE | FileUtils.IGNORE_ERRORS);
}
repoConfig.unset(ConfigConstants.CONFIG_EXTENSIONS_SECTION, null,
ConfigConstants.CONFIG_KEY_REF_STORAGE);
repoConfig.save();
}
/**
* Converts the RefDatabase from RefDirectory to reftable. This operation is
* not atomic.
*
* @param writeLogs
* whether to write reflogs
* @param backup
* whether to rename or delete the old storage files. If set to
* {@code true}, the loose refs are left in {@code refs.old}, the
* packed-refs in {@code packed-refs.old} and reflogs in
* {@code refs.old/}. HEAD is left in {@code HEAD.old} and also
* {@code .log} is appended to additional refs. If set to
* {@code false}, the {@code refs/} and {@code logs/} directories
* and {@code HEAD} and additional symbolic refs are removed.
* @throws IOException
* on IO problem
*/
@SuppressWarnings("nls")
void convertToReftable(boolean writeLogs, boolean backup)
throws IOException {
File reftableDir = new File(getDirectory(), Constants.REFTABLE);
File headFile = new File(getDirectory(), Constants.HEAD);
if (reftableDir.exists() && FileUtils.hasFiles(reftableDir.toPath())) {
throw new IOException(JGitText.get().reftableDirExists);
}
// Ignore return value, as it is tied to temporary newRefs file.
FileReftableDatabase.convertFrom(this, writeLogs);
File refsFile = new File(getDirectory(), "refs");
// non-atomic: remove old data.
File packedRefs = new File(getDirectory(), Constants.PACKED_REFS);
File logsDir = new File(getDirectory(), Constants.LOGS);
List<String> additional = getRefDatabase().getAdditionalRefs().stream()
.map(Ref::getName).collect(toList());
additional.add(Constants.HEAD);
if (backup) {
FileUtils.rename(refsFile, new File(getDirectory(), "refs.old"));
if (packedRefs.exists()) {
FileUtils.rename(packedRefs, new File(getDirectory(),
Constants.PACKED_REFS + ".old"));
}
if (logsDir.exists()) {
FileUtils.rename(logsDir,
new File(getDirectory(), Constants.LOGS + ".old"));
}
for (String r : additional) {
FileUtils.rename(new File(getDirectory(), r),
new File(getDirectory(), r + ".old"));
}
} else {
FileUtils.delete(packedRefs, FileUtils.SKIP_MISSING);
FileUtils.delete(headFile, FileUtils.SKIP_MISSING);
FileUtils.delete(logsDir,
FileUtils.RECURSIVE | FileUtils.SKIP_MISSING);
FileUtils.delete(refsFile,
FileUtils.RECURSIVE | FileUtils.SKIP_MISSING);
for (String r : additional) {
new File(getDirectory(), r).delete();
}
}
FileUtils.mkdir(refsFile, true);
// By putting in a dummy HEAD, old versions of Git still detect a repo
// (that they can't read)
try (OutputStream os = new FileOutputStream(headFile)) {
os.write(Constants.encodeASCII("ref: refs/heads/.invalid"));
}
// Some tools might write directly into .git/refs/heads/BRANCH. By
// putting a file here, this fails spectacularly.
FileUtils.createNewFile(new File(refsFile, "heads"));
repoConfig.setString(ConfigConstants.CONFIG_EXTENSIONS_SECTION, null,
ConfigConstants.CONFIG_KEY_REF_STORAGE,
ConfigConstants.CONFIG_REF_STORAGE_REFTABLE);
repoConfig.setLong(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_REPO_FORMAT_VERSION, 1);
repoConfig.save();
refs.close();
refs = new FileReftableDatabase(this);
}
/**
* Converts between ref storage formats.
*
* @param format
* the format to convert to, either "reftable" or "refdir"
* @param writeLogs
* whether to write reflogs
* @param backup
* whether to make a backup of the old data
* @throws IOException
* on I/O problems.
*/
public void convertRefStorage(String format, boolean writeLogs,
boolean backup) throws IOException {
if (format.equals("reftable")) { //$NON-NLS-1$
if (refs instanceof RefDirectory) {
convertToReftable(writeLogs, backup);
}
} else if (format.equals("refdir")) {//$NON-NLS-1$
if (refs instanceof FileReftableDatabase) {
convertToPackedRefs(writeLogs, backup);
}
} else {
throw new IOException(MessageFormat
.format(JGitText.get().unknownRefStorageFormat, format));
}
}
}