BlockBasedFile.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.EOFException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.text.MessageFormat;

import org.eclipse.jgit.errors.PackInvalidException;
import org.eclipse.jgit.internal.storage.pack.PackExt;

/** Block based file stored in {@link DfsBlockCache}. */
abstract class BlockBasedFile {
    /** Cache that owns this file and its data. */
    final DfsBlockCache cache;

    /** Unique identity of this file while in-memory. */
    final DfsStreamKey key;

    /** Description of the associated pack file's storage. */
    final DfsPackDescription desc;
    final PackExt ext;

    /**
     * Preferred alignment for loading blocks from the backing file.
     * <p>
     * It is initialized to 0 and filled in on the first read made from the
     * file. Block sizes may be odd, e.g. 4091, caused by the underling DFS
     * storing 4091 user bytes and 5 bytes block metadata into a lower level
     * 4096 byte block on disk.
     */
    volatile int blockSize;

    /**
     * Total number of bytes in this pack file.
     * <p>
     * This field initializes to -1 and gets populated when a block is loaded.
     */
    volatile long length;

    /** True once corruption has been detected that cannot be worked around. */
    volatile boolean invalid;

    /** Exception that caused the packfile to be flagged as invalid */
    protected volatile Exception invalidatingCause;

    BlockBasedFile(DfsBlockCache cache, DfsPackDescription desc, PackExt ext) {
        this.cache = cache;
        this.key = desc.getStreamKey(ext);
        this.desc = desc;
        this.ext = ext;
    }

    String getFileName() {
        return desc.getFileName(ext);
    }

    boolean invalid() {
        return invalid;
    }

    void setInvalid() {
        invalid = true;
    }

    void setBlockSize(int newSize) {
        blockSize = newSize;
    }

    long alignToBlock(long pos) {
        int size = blockSize;
        if (size == 0)
            size = cache.getBlockSize();
        return (pos / size) * size;
    }

    int blockSize(ReadableChannel rc) {
        // If the block alignment is not yet known, discover it. Prefer the
        // larger size from either the cache or the file itself.
        int size = blockSize;
        if (size == 0) {
            size = rc.blockSize();
            if (size <= 0)
                size = cache.getBlockSize();
            else if (size < cache.getBlockSize())
                size = (cache.getBlockSize() / size) * size;
            blockSize = size;
        }
        return size;
    }

    DfsBlock getOrLoadBlock(long pos, DfsReader ctx) throws IOException {
        try (LazyChannel c = new LazyChannel(ctx, desc, ext)) {
            return cache.getOrLoad(this, pos, ctx, c);
        }
    }

    DfsBlock readOneBlock(long pos, DfsReader ctx, ReadableChannel rc)
            throws IOException {
        if (invalid) {
            throw new PackInvalidException(getFileName(), invalidatingCause);
        }

        ctx.stats.readBlock++;
        long start = System.nanoTime();
        try {
            int size = blockSize(rc);
            pos = (pos / size) * size;

            // If the size of the file is not yet known, try to discover it.
            // Channels may choose to return -1 to indicate they don't
            // know the length yet, in this case read up to the size unit
            // given by the caller, then recheck the length.
            long len = length;
            if (len < 0) {
                len = rc.size();
                if (0 <= len)
                    length = len;
            }

            if (0 <= len && len < pos + size)
                size = (int) (len - pos);
            if (size <= 0)
                throw new EOFException(MessageFormat.format(
                        DfsText.get().shortReadOfBlock, Long.valueOf(pos),
                        getFileName(), Long.valueOf(0), Long.valueOf(0)));

            byte[] buf = new byte[size];
            rc.position(pos);
            int cnt = read(rc, ByteBuffer.wrap(buf, 0, size));
            ctx.stats.readBlockBytes += cnt;
            if (cnt != size) {
                if (0 <= len) {
                    throw new EOFException(MessageFormat.format(
                            DfsText.get().shortReadOfBlock, Long.valueOf(pos),
                            getFileName(), Integer.valueOf(size),
                            Integer.valueOf(cnt)));
                }

                // Assume the entire thing was read in a single shot, compact
                // the buffer to only the space required.
                byte[] n = new byte[cnt];
                System.arraycopy(buf, 0, n, 0, n.length);
                buf = n;
            } else if (len < 0) {
                // With no length at the start of the read, the channel should
                // have the length available at the end.
                length = len = rc.size();
            }

            return new DfsBlock(key, pos, buf);
        } finally {
            ctx.stats.readBlockMicros += elapsedMicros(start);
        }
    }

    static int read(ReadableChannel rc, ByteBuffer buf) throws IOException {
        int n;
        do {
            n = rc.read(buf);
        } while (0 < n && buf.hasRemaining());
        return buf.position();
    }

    static long elapsedMicros(long start) {
        return (System.nanoTime() - start) / 1000L;
    }

    /**
     * A supplier of readable channel that opens the channel lazily.
     */
    private static class LazyChannel
            implements AutoCloseable, DfsBlockCache.ReadableChannelSupplier {
        private final DfsReader ctx;
        private final DfsPackDescription desc;
        private final PackExt ext;

        private ReadableChannel rc;

        LazyChannel(DfsReader ctx, DfsPackDescription desc, PackExt ext) {
            this.ctx = ctx;
            this.desc = desc;
            this.ext = ext;
        }

        @Override
        public ReadableChannel get() throws IOException {
            if (rc == null) {
                rc = ctx.db.openFile(desc, ext);
            }
            return rc;
        }

        @Override
        public void close() throws IOException {
            if (rc != null) {
                rc.close();
            }
        }
    }
}