DfsReftableDatabase.java

/*
 * Copyright (C) 2017, Google Inc. 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.dfs;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import org.eclipse.jgit.annotations.Nullable;
import org.eclipse.jgit.internal.storage.reftable.MergedReftable;
import org.eclipse.jgit.internal.storage.reftable.ReftableConfig;
import org.eclipse.jgit.internal.storage.reftable.ReftableDatabase;
import org.eclipse.jgit.lib.BatchRefUpdate;
import org.eclipse.jgit.lib.NullProgressMonitor;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.transport.ReceiveCommand;
import org.eclipse.jgit.util.RefList;
import org.eclipse.jgit.util.RefMap;

/**
 * A {@link org.eclipse.jgit.internal.storage.dfs.DfsRefDatabase} that uses
 * reftable for storage.
 * <p>
 * A {@code DfsRefDatabase} instance is thread-safe.
 * <p>
 * Implementors may wish to use
 * {@link org.eclipse.jgit.internal.storage.dfs.DfsPackDescription#getMaxUpdateIndex()}
 * as the primary key identifier for a
 * {@link org.eclipse.jgit.internal.storage.pack.PackExt#REFTABLE} only pack
 * description, ensuring that when there are competing transactions one wins,
 * and one will fail.
 */
public class DfsReftableDatabase extends DfsRefDatabase {
    final ReftableDatabase reftableDatabase;

    private DfsReader ctx;
    private DfsReftableStack stack;

    /**
     * Initialize the reference database for a repository.
     *
     * @param repo
     *            the repository this database instance manages references for.
     */
    protected DfsReftableDatabase(DfsRepository repo) {
        super(repo);
        reftableDatabase = new ReftableDatabase() {
            @Override
            public MergedReftable openMergedReftable() throws IOException {
                Lock l = DfsReftableDatabase.this.getLock();
                l.lock();
                try {
                    return new MergedReftable(stack().readers());
                } finally {
                    l.unlock();
                }
            }
        };
        stack = null;
    }

    /** {@inheritDoc} */
    @Override
    public boolean hasVersioning() {
        return true;
    }

    /** {@inheritDoc} */
    @Override
    public boolean performsAtomicTransactions() {
        return true;
    }

    /** {@inheritDoc} */
    @Override
    public BatchRefUpdate newBatchUpdate() {
        DfsObjDatabase odb = getRepository().getObjectDatabase();
        return new DfsReftableBatchRefUpdate(this, odb);
    }

    /**
     * Get configuration to write new reftables with.
     *
     * @return configuration to write new reftables with.
     */
    public ReftableConfig getReftableConfig() {
        return new ReftableConfig(getRepository());
    }

    /**
     * Get the lock protecting this instance's state.
     *
     * @return the lock protecting this instance's state.
     */
    protected ReentrantLock getLock() {
        return reftableDatabase.getLock();
    }

    /**
     * Whether to compact reftable instead of extending the stack depth.
     *
     * @return {@code true} if commit of a new small reftable should try to
     *         replace a prior small reftable by performing a compaction,
     *         instead of extending the stack depth.
     */
    protected boolean compactDuringCommit() {
        return true;
    }


    /**
     * Obtain a handle to the stack of reftables. Must hold lock.
     *
     * @return (possibly cached) handle to the stack.
     * @throws java.io.IOException
     *             if tables cannot be opened.
     */
    protected DfsReftableStack stack() throws IOException {
        if (!getLock().isLocked()) {
            throw new IllegalStateException("most hold lock to access stack"); //$NON-NLS-1$
        }
        DfsObjDatabase odb = getRepository().getObjectDatabase();

        if (ctx == null) {
            ctx = odb.newReader();
        }
        if (stack == null) {
            stack = DfsReftableStack.open(ctx, Arrays.asList(odb.getReftables()));
        }
        return stack;
    }

    @Override
    public boolean isNameConflicting(String refName) throws IOException {
        return reftableDatabase.isNameConflicting(refName, new TreeSet<>(), new HashSet<>());
    }

    /** {@inheritDoc} */
    @Override
    public Ref exactRef(String name) throws IOException {
        return reftableDatabase.exactRef(name);
    }

    /** {@inheritDoc} */
    @Override
    public Map<String, Ref> getRefs(String prefix) throws IOException {
        List<Ref> refs = reftableDatabase.getRefsByPrefix(prefix);
        RefList.Builder<Ref> builder = new RefList.Builder<>(refs.size());
        for (Ref r : refs) {
            builder.add(r);
        }
        return new RefMap(prefix, builder.toRefList(), RefList.emptyList(),
            RefList.emptyList());
    }

    /** {@inheritDoc} */
    @Override
    public List<Ref> getRefsByPrefix(String prefix) throws IOException {

        return reftableDatabase.getRefsByPrefix(prefix);
    }

    /** {@inheritDoc} */
    @Override
    public List<Ref> getRefsByPrefixWithExclusions(String include, Set<String> excludes)
            throws IOException {
        return reftableDatabase.getRefsByPrefixWithExclusions(include, excludes);
    }

    /** {@inheritDoc} */
    @Override
    public Set<Ref> getTipsWithSha1(ObjectId id) throws IOException {
        if (!getReftableConfig().isIndexObjects()) {
            return super.getTipsWithSha1(id);
        }
        return reftableDatabase.getTipsWithSha1(id);
    }

    /** {@inheritDoc} */
    @Override
    public boolean hasFastTipsWithSha1() throws IOException {
        return reftableDatabase.hasFastTipsWithSha1();
    }

    /** {@inheritDoc} */
    @Override
    public Ref peel(Ref ref) throws IOException {
        Ref oldLeaf = ref.getLeaf();
        if (oldLeaf.isPeeled() || oldLeaf.getObjectId() == null) {
            return ref;
        }
        return recreate(ref, doPeel(oldLeaf), hasVersioning());
    }

    @Override
    boolean exists() throws IOException {
        DfsObjDatabase odb = getRepository().getObjectDatabase();
        return odb.getReftables().length > 0;
    }

    @Override
    void clearCache() {
        ReentrantLock l = getLock();
        l.lock();
        try {
            if (ctx != null) {
                ctx.close();
                ctx = null;
            }
            reftableDatabase.clearCache();
            if (stack != null) {
                stack.close();
                stack = null;
            }
        } finally {
            l.unlock();
        }
    }

    /** {@inheritDoc} */
    @Override
    protected boolean compareAndPut(Ref oldRef, @Nullable Ref newRef)
            throws IOException {
        ReceiveCommand cmd = ReftableDatabase.toCommand(oldRef, newRef);
        try (RevWalk rw = new RevWalk(getRepository())) {
            rw.setRetainBody(false);
            newBatchUpdate().setAllowNonFastForwards(true).addCommand(cmd)
                    .execute(rw, NullProgressMonitor.INSTANCE);
        }
        switch (cmd.getResult()) {
        case OK:
            return true;
        case REJECTED_OTHER_REASON:
            throw new IOException(cmd.getMessage());
        case LOCK_FAILURE:
        default:
            return false;
        }
    }

    /** {@inheritDoc} */
    @Override
    protected boolean compareAndRemove(Ref oldRef) throws IOException {
        return compareAndPut(oldRef, null);
    }

    /** {@inheritDoc} */
    @Override
    protected RefCache scanAllRefs() throws IOException {
        throw new UnsupportedOperationException();
    }

    @Override
    void stored(Ref ref) {
        // Unnecessary; DfsReftableBatchRefUpdate calls clearCache().
    }

    @Override
    void removed(String refName) {
        // Unnecessary; DfsReftableBatchRefUpdate calls clearCache().
    }

    /** {@inheritDoc} */
    @Override
    protected void cachePeeledState(Ref oldLeaf, Ref newLeaf) {
        // Do not cache peeled state in reftable.
    }

}