com.google.archivepatcher.generator.bsdiff.RandomAccessObject Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of archive-patcher Show documentation
Show all versions of archive-patcher Show documentation
Google Archive Patcher (EIDU fork)
The newest version!
// Copyright 2016 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.archivepatcher.generator.bsdiff;
import java.io.Closeable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
// TODO(andrewhayden): clean up the implementations, we only really need two and they can be in
// separate files.
/**
* Interface which offers random access interface. This class exists to allow BsDiff to use either
* a RandomAccessFile for disk-based io, or a byte[] for fully in-memory operation.
*/
public interface RandomAccessObject extends DataInput, DataOutput, Closeable {
/**
* Returns the length of the file or byte array associated with the RandomAccessObject.
*
* @return the length of the file or byte array associated with the RandomAccessObject
* @throws IOException if unable to determine the length of the file, when backed by a file
*/
public long length() throws IOException;
/**
* Seeks to a specified position, in bytes, into the file or byte array.
*
* @param pos the position to seek to
* @throws IOException if seeking fails
*/
public void seek(long pos) throws IOException;
/**
* Seek to a specified integer-aligned position in the associated file or byte array. For example,
* seekToIntAligned(5) will seek to the beginning of the 5th integer, or in other words the 20th
* byte. In general, seekToIntAligned(n) will seek to byte 4n.
*
* @param pos the position to seek to
* @throws IOException if seeking fails
*/
public void seekToIntAligned(long pos) throws IOException;
/**
* A {@link RandomAccessFile}-based implementation of {@link RandomAccessObject} which just
* delegates all operations to the equivalents in {@link RandomAccessFile}. Slower than the
* {@link RandomAccessMmapObject} implementation.
*/
public static final class RandomAccessFileObject extends RandomAccessFile
implements RandomAccessObject {
private final boolean mShouldDeleteFileOnClose;
private final File mFile;
/**
* This constructor takes in a temporary file. This constructor does not take ownership of the
* file, and the file will not be deleted on {@link #close()}.
*
* @param tempFile the file backing this object
* @param mode the mode to use, e.g. "r" or "w" for read or write
* @throws IOException if unable to open the file for the specified mode
*/
public RandomAccessFileObject(final File tempFile, final String mode) throws IOException {
this(tempFile, mode, false);
}
/**
* This constructor takes in a temporary file. If deleteFileOnClose is true, the constructor
* takes ownership of that file, and this file is deleted on close().
*
* @param tempFile the file backing this object
* @param mode the mode to use, e.g. "r" or "w" for read or write
* @param deleteFileOnClose if true the constructor takes ownership of that file, and this file
* is deleted on close().
* @throws IOException if unable to open the file for the specified mode
* @throws IllegalArgumentException if the size of the file is too great
*/
// TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
// really be the responsibility of RandomAccessObject.
public RandomAccessFileObject(final File tempFile, final String mode, boolean deleteFileOnClose)
throws IOException {
super(tempFile, mode);
mShouldDeleteFileOnClose = deleteFileOnClose;
mFile = tempFile;
if (mShouldDeleteFileOnClose) {
mFile.deleteOnExit();
}
}
@Override
public void seekToIntAligned(long pos) throws IOException {
seek(pos * 4);
}
/**
* Close the associated file. Also delete the associated temp file if specified in the
* constructor. This should be called on every RandomAccessObject when it is no longer needed.
*/
// TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
// really be the responsibility of RandomAccessObject.
@Override
public void close() throws IOException {
super.close();
if (mShouldDeleteFileOnClose) {
mFile.delete();
}
}
}
/**
* An array-based implementation of {@link RandomAccessObject} for entirely in-memory operations.
*/
public static class RandomAccessByteArrayObject implements RandomAccessObject {
protected ByteBuffer mByteBuffer;
/**
* The passed-in byte array will be treated as big-endian when dealing with ints.
*
* @param byteArray the byte array to wrap
*/
public RandomAccessByteArrayObject(final byte[] byteArray) {
mByteBuffer = ByteBuffer.wrap(byteArray);
}
/**
* Allocate a new ByteBuffer of given length. This will be treated as big-endian.
*
* @param length the length of the buffer to allocate
*/
public RandomAccessByteArrayObject(final int length) {
mByteBuffer = ByteBuffer.allocate(length);
}
protected RandomAccessByteArrayObject() {
// No-op, this is just used by the extending class RandomAccessMmapObject.
}
@Override
public long length() {
return mByteBuffer.capacity();
}
@Override
public byte readByte() {
return mByteBuffer.get();
}
/**
* Reads an integer from the underlying data array in big-endian order.
*/
@Override
public int readInt() {
return mByteBuffer.getInt();
}
public void writeByte(byte b) {
mByteBuffer.put(b);
}
@Override
public void writeInt(int i) {
mByteBuffer.putInt(i);
}
/**
* RandomAccessByteArrayObject.seek() only supports addresses up to 2^31-1, due to the fact
* that it needs to support byte[] backend (and in Java, arrays are indexable only by int).
* This means that it can only seek up to a 2GiB byte[].
*/
@Override
public void seek(long pos) {
if (pos > Integer.MAX_VALUE) {
throw new IllegalArgumentException(
"RandomAccessByteArrayObject can only handle seek() "
+ "addresses up to Integer.MAX_VALUE.");
}
mByteBuffer.position((int) pos);
}
@Override
public void seekToIntAligned(long pos) {
seek(pos * 4);
}
@Override
public void close() throws IOException {
// Nothing necessary.
}
@Override
public boolean readBoolean() {
return readByte() != 0;
}
@Override
public char readChar() {
return mByteBuffer.getChar();
}
@Override
public double readDouble() {
return mByteBuffer.getDouble();
}
@Override
public float readFloat() {
return mByteBuffer.getFloat();
}
@Override
public void readFully(byte[] b) {
mByteBuffer.get(b);
}
@Override
public void readFully(byte[] b, int off, int len) {
mByteBuffer.get(b, off, len);
}
@Override
public String readLine() {
throw new UnsupportedOperationException();
}
@Override
public long readLong() {
return mByteBuffer.getLong();
}
@Override
public short readShort() {
return mByteBuffer.getShort();
}
@Override
public int readUnsignedByte() {
return mByteBuffer.get() & 0xff;
}
@Override
public int readUnsignedShort() {
throw new UnsupportedOperationException();
}
@Override
public String readUTF() {
throw new UnsupportedOperationException();
}
@Override
public int skipBytes(int n) {
mByteBuffer.position(mByteBuffer.position() + n);
return n;
}
@Override
public void write(byte[] b) {
mByteBuffer.put(b);
}
@Override
public void write(byte[] b, int off, int len) {
mByteBuffer.put(b, off, len);
}
@Override
public void write(int b) {
writeByte((byte) b);
}
@Override
public void writeBoolean(boolean v) {
writeByte(v ? (byte) 1 : (byte) 0);
}
@Override
public void writeByte(int v) {
writeByte((byte) v);
}
@Override
public void writeBytes(String s) {
for (int x = 0; x < s.length(); x++) {
writeByte((byte) s.charAt(x));
}
}
@Override
public void writeChar(int v) {
mByteBuffer.putChar((char) v);
}
@Override
public void writeChars(String s) {
for (int x = 0; x < s.length(); x++) {
writeChar(s.charAt(x));
}
}
@Override
public void writeDouble(double v) {
mByteBuffer.putDouble(v);
}
@Override
public void writeFloat(float v) {
mByteBuffer.putFloat(v);
}
@Override
public void writeLong(long v) {
mByteBuffer.putLong(v);
}
@Override
public void writeShort(int v) {
mByteBuffer.putShort((short) v);
}
@Override
public void writeUTF(String s) {
throw new UnsupportedOperationException();
}
}
/**
* A {@link ByteBuffer}-based implementation of {@link RandomAccessObject} that uses files on
* disk, but is significantly faster than the RandomAccessFile implementation.
*/
public static final class RandomAccessMmapObject extends RandomAccessByteArrayObject {
private final boolean mShouldDeleteFileOnRelease;
private final File mFile;
private final FileChannel mFileChannel;
public RandomAccessMmapObject(final RandomAccessFile randomAccessFile, String mode)
throws IOException, IllegalArgumentException {
if (randomAccessFile.length() > Integer.MAX_VALUE) {
throw new IllegalArgumentException("Only files up to 2GiB in size are supported.");
}
FileChannel.MapMode mapMode;
if (mode.equals("r")) {
mapMode = FileChannel.MapMode.READ_ONLY;
} else {
mapMode = FileChannel.MapMode.READ_WRITE;
}
mFileChannel = randomAccessFile.getChannel();
mByteBuffer = mFileChannel.map(mapMode, 0, randomAccessFile.length());
mByteBuffer.position(0);
mShouldDeleteFileOnRelease = false;
mFile = null;
}
/**
* This constructor creates a temporary file. This file is deleted on close(), so be sure to
* call it when you're done, otherwise it'll leave stray files.
*
* @param tempFileName the path to the file backing this object
* @param mode the mode to use, e.g. "r" or "w" for read or write
* @param length the size of the file to be read or written
* @throws IOException if unable to open the file for the specified mode
* @throws IllegalArgumentException if the size of the file is too great
*/
// TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
// really be the responsibility of RandomAccessObject.
@SuppressWarnings("resource") // RandomAccessFile deliberately left open
public RandomAccessMmapObject(final String tempFileName, final String mode, long length)
throws IOException, IllegalArgumentException {
if (length > Integer.MAX_VALUE) {
throw new IllegalArgumentException(
"RandomAccessMmapObject only supports file sizes up to " + "Integer.MAX_VALUE.");
}
mFile = File.createTempFile(tempFileName, "temp");
mFile.deleteOnExit();
mShouldDeleteFileOnRelease = true;
FileChannel.MapMode mapMode;
if (mode.equals("r")) {
mapMode = FileChannel.MapMode.READ_ONLY;
} else {
mapMode = FileChannel.MapMode.READ_WRITE;
}
RandomAccessFile file = null;
try {
file = new RandomAccessFile(mFile, mode);
mFileChannel = file.getChannel();
mByteBuffer = mFileChannel.map(mapMode, 0, (int) length);
mByteBuffer.position(0);
} catch (IOException e) {
if (file != null) {
try {
file.close();
} catch (Exception ignored) {
// Nothing more can be done
}
}
close();
throw new IOException("Unable to open file", e);
}
}
/**
* This constructor takes in a temporary file, and takes ownership of that file. This file is
* deleted on close() OR IF THE CONSTRUCTOR FAILS. The main purpose of this constructor is to
* test close() on the passed-in file.
*
* @param tempFile the the file backing this object
* @param mode the mode to use, e.g. "r" or "w" for read or write
* @throws IOException if unable to open the file for the specified mode
* @throws IllegalArgumentException if the size of the file is too great
*/
// TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
// really be the responsibility of RandomAccessObject.
@SuppressWarnings("resource") // RandomAccessFile deliberately left open
public RandomAccessMmapObject(final File tempFile, final String mode)
throws IOException, IllegalArgumentException {
if (tempFile.length() > Integer.MAX_VALUE) {
throw new IllegalArgumentException("Only files up to 2GiB in size are supported.");
}
mFile = tempFile;
mFile.deleteOnExit();
mShouldDeleteFileOnRelease = true;
FileChannel.MapMode mapMode;
if (mode.equals("r")) {
mapMode = FileChannel.MapMode.READ_ONLY;
} else {
mapMode = FileChannel.MapMode.READ_WRITE;
}
RandomAccessFile file = null;
try {
file = new RandomAccessFile(mFile, mode);
mFileChannel = file.getChannel();
mByteBuffer = mFileChannel.map(mapMode, 0, tempFile.length());
mByteBuffer.position(0);
} catch (IOException e) {
if (file != null) {
try {
file.close();
} catch (Exception ignored) {
// Nothing more can be done
}
}
close();
throw new IOException("Unable to open file", e);
}
}
@Override
public void close() throws IOException {
if (mFileChannel != null) {
mFileChannel.close();
}
// There is a long-standing bug with memory mapped objects in Java that requires the JVM to
// finalize the MappedByteBuffer reference before the unmap operation is performed. This leaks
// file handles and fills the virtual address space. Worse, on some systems (Windows for one)
// the active mmap prevents the temp file from being deleted - even if File.deleteOnExit() is
// used. The only safe way to ensure that file handles and actual files are not leaked by this
// class is to force an explicit full gc after explicitly nulling the MappedByteBuffer
// reference. This has to be done before attempting file deletion.
//
// See https://github.com/andrewhayden/archive-patcher/issues/5 for more information.
mByteBuffer = null;
System.gc();
if (mShouldDeleteFileOnRelease && mFile != null) {
mFile.delete();
}
}
}
}