RefDirectoryRename.java

/*
 * Copyright (C) 2010, Google Inc.
 * Copyright (C) 2009, Robin Rosenberg 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 java.io.File;
import java.io.IOException;
import java.nio.file.AtomicMoveNotSupportedException;
import java.nio.file.StandardCopyOption;

import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.RefRename;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.util.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Rename any reference stored by {@link RefDirectory}.
 * <p>
 * This class works by first renaming the source reference to a temporary name,
 * then renaming the temporary name to the final destination reference.
 * <p>
 * This strategy permits switching a reference like {@code refs/heads/foo},
 * which is a file, to {@code refs/heads/foo/bar}, which is stored inside a
 * directory that happens to match the source name.
 */
class RefDirectoryRename extends RefRename {
    private static final Logger LOG = LoggerFactory
            .getLogger(RefDirectoryRename.class);

    private final RefDirectory refdb;

    /**
     * The value of the source reference at the start of the rename.
     * <p>
     * At the end of the rename the destination reference must have this same
     * value, otherwise we have a concurrent update and the rename must fail
     * without making any changes.
     */
    private ObjectId objId;

    /** A reference we backup {@link #objId} into during the rename. */
    private RefDirectoryUpdate tmp;

    RefDirectoryRename(RefDirectoryUpdate src, RefDirectoryUpdate dst) {
        super(src, dst);
        refdb = src.getRefDatabase();
    }

    /** {@inheritDoc} */
    @Override
    protected Result doRename() throws IOException {
        if (source.getRef().isSymbolic())
            return Result.IO_FAILURE; // not supported

        objId = source.getOldObjectId();
        boolean updateHEAD = needToUpdateHEAD();
        tmp = refdb.newTemporaryUpdate();
        try (RevWalk rw = new RevWalk(refdb.getRepository())) {
            // First backup the source so its never unreachable.
            tmp.setNewObjectId(objId);
            tmp.setForceUpdate(true);
            tmp.disableRefLog();
            switch (tmp.update(rw)) {
            case NEW:
            case FORCED:
            case NO_CHANGE:
                break;
            default:
                return tmp.getResult();
            }

            // Save the source's log under the temporary name, we must do
            // this before we delete the source, otherwise we lose the log.
            if (!renameLog(source, tmp))
                return Result.IO_FAILURE;

            // If HEAD has to be updated, link it now to destination.
            // We have to link before we delete, otherwise the delete
            // fails because its the current branch.
            RefUpdate dst = destination;
            if (updateHEAD) {
                if (!linkHEAD(destination)) {
                    renameLog(tmp, source);
                    return Result.LOCK_FAILURE;
                }

                // Replace the update operation so HEAD will log the rename.
                dst = refdb.newUpdate(Constants.HEAD, false);
                dst.setRefLogIdent(destination.getRefLogIdent());
                dst.setRefLogMessage(destination.getRefLogMessage(), false);
            }

            // Delete the source name so its path is free for replacement.
            source.setExpectedOldObjectId(objId);
            source.setForceUpdate(true);
            source.disableRefLog();
            if (source.delete(rw) != Result.FORCED) {
                renameLog(tmp, source);
                if (updateHEAD)
                    linkHEAD(source);
                return source.getResult();
            }

            // Move the log to the destination.
            if (!renameLog(tmp, destination)) {
                renameLog(tmp, source);
                source.setExpectedOldObjectId(ObjectId.zeroId());
                source.setNewObjectId(objId);
                source.update(rw);
                if (updateHEAD)
                    linkHEAD(source);
                return Result.IO_FAILURE;
            }

            // Create the destination, logging the rename during the creation.
            dst.setExpectedOldObjectId(ObjectId.zeroId());
            dst.setNewObjectId(objId);
            if (dst.update(rw) != Result.NEW) {
                // If we didn't create the destination we have to undo
                // our work. Put the log back and restore source.
                if (renameLog(destination, tmp))
                    renameLog(tmp, source);
                source.setExpectedOldObjectId(ObjectId.zeroId());
                source.setNewObjectId(objId);
                source.update(rw);
                if (updateHEAD)
                    linkHEAD(source);
                return dst.getResult();
            }

            return Result.RENAMED;
        } finally {
            // Always try to free the temporary name.
            try {
                refdb.delete(tmp);
            } catch (IOException err) {
                FileUtils.delete(refdb.fileFor(tmp.getName()));
            }
        }
    }

    private boolean renameLog(RefUpdate src, RefUpdate dst) {
        File srcLog = refdb.logFor(src.getName());
        File dstLog = refdb.logFor(dst.getName());

        if (!srcLog.exists())
            return true;

        if (!rename(srcLog, dstLog))
            return false;

        try {
            final int levels = RefDirectory.levelsIn(src.getName()) - 2;
            RefDirectory.delete(srcLog, levels);
            return true;
        } catch (IOException e) {
            rename(dstLog, srcLog);
            return false;
        }
    }

    private static boolean rename(File src, File dst) {
        try {
            FileUtils.rename(src, dst, StandardCopyOption.ATOMIC_MOVE);
            return true;
        } catch (AtomicMoveNotSupportedException e) {
            LOG.error(e.getMessage(), e);
        } catch (IOException e) {
            // ignore
        }

        File dir = dst.getParentFile();
        if ((dir.exists() || !dir.mkdirs()) && !dir.isDirectory())
            return false;
        try {
            FileUtils.rename(src, dst, StandardCopyOption.ATOMIC_MOVE);
            return true;
        } catch (IOException e) {
            LOG.error(e.getMessage(), e);
            return false;
        }
    }

    private boolean linkHEAD(RefUpdate target) {
        try {
            RefUpdate u = refdb.newUpdate(Constants.HEAD, false);
            u.disableRefLog();
            switch (u.link(target.getName())) {
            case NEW:
            case FORCED:
            case NO_CHANGE:
                return true;
            default:
                return false;
            }
        } catch (IOException e) {
            return false;
        }
    }
}