FixedLengthBlockOutputStream.java
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.commons.compress.utils;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.WritableByteChannel;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* This class supports writing to an OutputStream or WritableByteChannel in fixed length blocks.
* <p>
* It can be be used to support output to devices such as tape drives that require output in this format. If the final block does not have enough content to
* fill an entire block, the output will be padded to a full block size.
* </p>
*
* <p>
* This class can be used to support TAR,PAX, and CPIO blocked output to character special devices. It is not recommended that this class be used unless writing
* to such devices, as the padding serves no useful purpose in such cases.
* </p>
*
* <p>
* This class should normally wrap a FileOutputStream or associated WritableByteChannel directly. If there is an intervening filter that modified the output,
* such as a CompressorOutputStream, or performs its own buffering, such as BufferedOutputStream, output to the device may no longer be of the specified size.
* </p>
*
* <p>
* Any content written to this stream should be self-delimiting and should tolerate any padding added to fill the last block.
* </p>
*
* @since 1.15
*/
public class FixedLengthBlockOutputStream extends OutputStream implements WritableByteChannel {
/**
* Helper class to provide channel wrapper for arbitrary output stream that doesn't alter the size of writes. We can't use Channels.newChannel, because for
* non FileOutputStreams, it breaks up writes into 8KB max chunks. Since the purpose of this class is to always write complete blocks, we need to write a
* simple class to take care of it.
*/
private static final class BufferAtATimeOutputChannel implements WritableByteChannel {
private final OutputStream out;
private final AtomicBoolean closed = new AtomicBoolean();
private BufferAtATimeOutputChannel(final OutputStream out) {
this.out = out;
}
@Override
public void close() throws IOException {
if (closed.compareAndSet(false, true)) {
out.close();
}
}
@Override
public boolean isOpen() {
return !closed.get();
}
@Override
public int write(final ByteBuffer buffer) throws IOException {
if (!isOpen()) {
throw new ClosedChannelException();
}
if (!buffer.hasArray()) {
throw new IOException("Direct buffer somehow written to BufferAtATimeOutputChannel");
}
try {
final int pos = buffer.position();
final int len = buffer.limit() - pos;
out.write(buffer.array(), buffer.arrayOffset() + pos, len);
buffer.position(buffer.limit());
return len;
} catch (final IOException e) {
try {
close();
} catch (final IOException ignored) { // NOSONAR
}
throw e;
}
}
}
private final WritableByteChannel out;
private final int blockSize;
private final ByteBuffer buffer;
private final AtomicBoolean closed = new AtomicBoolean();
/**
* Constructs a fixed length block output stream with given destination stream and block size.
*
* @param os The stream to wrap.
* @param blockSize The block size to use.
*/
public FixedLengthBlockOutputStream(final OutputStream os, final int blockSize) {
if (os instanceof FileOutputStream) {
final FileOutputStream fileOutputStream = (FileOutputStream) os;
out = fileOutputStream.getChannel();
buffer = ByteBuffer.allocateDirect(blockSize);
} else {
out = new BufferAtATimeOutputChannel(os);
buffer = ByteBuffer.allocate(blockSize);
}
this.blockSize = blockSize;
}
/**
* Constructs a fixed length block output stream with given destination writable byte channel and block size.
*
* @param out The writable byte channel to wrap.
* @param blockSize The block size to use.
*/
public FixedLengthBlockOutputStream(final WritableByteChannel out, final int blockSize) {
this.out = out;
this.blockSize = blockSize;
this.buffer = ByteBuffer.allocateDirect(blockSize);
}
@Override
public void close() throws IOException {
if (closed.compareAndSet(false, true)) {
try {
flushBlock();
} finally {
out.close();
}
}
}
/**
* Potentially pads and then writes the current block to the underlying stream.
*
* @throws IOException if writing fails
*/
public void flushBlock() throws IOException {
if (buffer.position() != 0) {
padBlock();
writeBlock();
}
}
@Override
public boolean isOpen() {
if (!out.isOpen()) {
closed.set(true);
}
return !closed.get();
}
private void maybeFlush() throws IOException {
if (!buffer.hasRemaining()) {
writeBlock();
}
}
private void padBlock() {
buffer.order(ByteOrder.nativeOrder());
int bytesToWrite = buffer.remaining();
if (bytesToWrite > 8) {
final int align = buffer.position() & 7;
if (align != 0) {
final int limit = 8 - align;
for (int i = 0; i < limit; i++) {
buffer.put((byte) 0);
}
bytesToWrite -= limit;
}
while (bytesToWrite >= 8) {
buffer.putLong(0L);
bytesToWrite -= 8;
}
}
while (buffer.hasRemaining()) {
buffer.put((byte) 0);
}
}
@Override
public void write(final byte[] b, final int offset, final int length) throws IOException {
if (!isOpen()) {
throw new ClosedChannelException();
}
int off = offset;
int len = length;
while (len > 0) {
final int n = Math.min(len, buffer.remaining());
buffer.put(b, off, n);
maybeFlush();
len -= n;
off += n;
}
}
@Override
public int write(final ByteBuffer src) throws IOException {
if (!isOpen()) {
throw new ClosedChannelException();
}
final int srcRemaining = src.remaining();
if (srcRemaining < buffer.remaining()) {
// if we don't have enough bytes in src to fill up a block we must buffer
buffer.put(src);
} else {
int srcLeft = srcRemaining;
final int savedLimit = src.limit();
// If we're not at the start of buffer, we have some bytes already buffered
// fill up the reset of buffer and write the block.
if (buffer.position() != 0) {
final int n = buffer.remaining();
src.limit(src.position() + n);
buffer.put(src);
writeBlock();
srcLeft -= n;
}
// whilst we have enough bytes in src for complete blocks,
// write them directly from src without copying them to buffer
while (srcLeft >= blockSize) {
src.limit(src.position() + blockSize);
out.write(src);
srcLeft -= blockSize;
}
// copy any remaining bytes into buffer
src.limit(savedLimit);
buffer.put(src);
}
return srcRemaining;
}
@Override
public void write(final int b) throws IOException {
if (!isOpen()) {
throw new ClosedChannelException();
}
buffer.put((byte) b);
maybeFlush();
}
private void writeBlock() throws IOException {
buffer.flip();
final int i = out.write(buffer);
final boolean hasRemaining = buffer.hasRemaining();
if (i != blockSize || hasRemaining) {
final String msg = String.format("Failed to write %,d bytes atomically. Only wrote %,d", blockSize, i);
throw new IOException(msg);
}
buffer.clear();
}
}