private void closeCurrentStream() throws IOException {
currentWriter.flush();
WGLOG.info("I04002", resourceName, processName, currentPath, currentStream.getCount());
bytesCount += currentStream.getCount();
try {
currentStream.close();
} catch (IOException e) {
WGLOG.error(e, "E04002", resourceName, processName, currentPath);
throw e;
}
currentPath = null;
currentStream = null;
currentWriter = null;
}
@Override
public void close() throws IOException {
if (!finished) {
finish();
}
stream.close();
}
private void validate() throws IOException {
long compressedSize = outCounted.getSize();
// It is very hard to trigger this exception.
// This is just to be pedantic.
if (compressedSize < 0 || compressedSize > compressedSizeLimit || uncompressedSize < 0)
throw new XZIOException("XZ Stream has grown too big");
}
/**
* Writes the local file header for the ZIP entry and positions the stream to the start of the
* entry data.
*
* @param e the ZIP entry for which to write the local file header
* @throws ZipException if a ZIP file error has occurred
* @throws IOException if an I/O exception has occurred
*/
private void startEntry(ZipFileEntry e) throws IOException {
if (e.getTime() == -1) {
throw new IllegalArgumentException("Zip entry last modified time must be set");
}
if (e.getCrc() == -1) {
throw new IllegalArgumentException("Zip entry CRC-32 must be set");
}
if (e.getSize() == -1) {
throw new IllegalArgumentException("Zip entry uncompressed size must be set");
}
if (e.getCompressedSize() == -1) {
throw new IllegalArgumentException("Zip entry compressed size must be set");
}
bytesWritten = 0;
entry = e;
entry.setFlag(Flag.DATA_DESCRIPTOR, false);
entry.setLocalHeaderOffset(stream.getCount());
stream.write(LocalFileHeader.create(entry, zipData, allowZip64));
}
@Override
public void put(T object) throws IOException {
if (currentWriter == null || currentStream.getCount() >= eachStreamSize) {
if (currentWriter != null) {
closeCurrentStream();
}
prepareNextStream();
}
currentWriter.write(object);
}
public void finish() throws IOException {
// Finish the Compressed Data field.
filterChain.finish();
validate();
// Block Padding
for (long i = outCounted.getSize(); (i & 3) != 0; ++i) out.write(0x00);
// Check
out.write(check.finish());
}
@Override
public synchronized void write(byte[] b, int off, int len) throws IOException {
checkNotFinished();
if (entry == null && !writingPrefix) {
throw new ZipException(
"Cannot write zip contents without first setting a ZipEntry or"
+ " starting a prefix file.");
}
stream.write(b, off, len);
bytesWritten += len;
}
public long getUnpaddedSize() {
return headerSize + outCounted.getSize() + check.getSize();
}
/**
* Writes the ZIP file's central directory.
*
* @throws ZipException if a ZIP file error has occurred
* @throws IOException if an I/O exception has occurred
*/
private void writeCentralDirectory() throws IOException {
zipData.setCentralDirectoryOffset(stream.getCount());
CentralDirectory.write(zipData, allowZip64, stream);
}
public void close() throws IOException {
if (myIsClosed) {
return;
}
myIsClosed = true;
final long truncateToSize[] = new long[] {-1};
try {
ByteArrayInputStream target = new ByteArrayInputStream(myTextBuffer.toByteArray());
myDeltaGenerator.sendDelta(null, mySourceStream, mySourceOffset, target, this, false);
final FSRepresentation rep = new FSRepresentation();
rep.setOffset(myRepOffset);
long offset = myTargetFileOS.getPosition();
rep.setSize(offset - myDeltaStart);
rep.setExpandedSize(myRepSize);
rep.setTxnId(myRevNode.getId().getTxnID());
String uniqueSuffix = myTxnRoot.getNewTxnNodeId();
String uniquifier = rep.getTxnId() + '/' + uniqueSuffix;
rep.setUniquifier(uniquifier);
rep.setRevision(SVNRepository.INVALID_REVISION);
rep.setMD5HexDigest(SVNFileUtil.toHexDigest(myMD5Digest));
rep.setSHA1HexDigest(SVNFileUtil.toHexDigest(mySHA1Digest));
FSFS fsfs = myTxnRoot.getOwner();
final IFSRepresentationCacheManager reposCacheManager = fsfs.getRepositoryCacheManager();
if (reposCacheManager != null) {
try {
reposCacheManager.runReadTransaction(
new IFSSqlJetTransaction() {
public void run() throws SVNException {
final FSRepresentation oldRep =
reposCacheManager.getRepresentationByHash(rep.getSHA1HexDigest());
if (oldRep != null) {
oldRep.setUniquifier(rep.getUniquifier());
oldRep.setMD5HexDigest(rep.getMD5HexDigest());
truncateToSize[0] = myRepOffset;
myRevNode.setTextRepresentation(oldRep);
}
}
});
} catch (SVNException e) {
// explicitly ignore.
SVNDebugLog.getDefaultLog().logError(SVNLogType.FSFS, e);
}
}
if (truncateToSize[0] < 0) {
myTargetFileOS.write("ENDREP\n".getBytes("UTF-8"));
myRevNode.setTextRepresentation(rep);
}
myRevNode.setIsFreshTxnRoot(false);
fsfs.putTxnRevisionNode(myRevNode.getId(), myRevNode);
} catch (SVNException svne) {
throw new IOException(svne.getMessage());
} finally {
closeStreams(truncateToSize[0]);
try {
myTxnLock.unlock();
} catch (SVNException e) {
//
}
FSWriteLock.release(myTxnLock);
}
}
public static OutputStream createStream(
FSRevisionNode revNode, FSTransactionRoot txnRoot, OutputStream dstStream, boolean compress)
throws SVNException {
if (revNode.getType() != SVNNodeKind.FILE) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.FS_NOT_FILE, "Attempted to set textual contents of a *non*-file node");
SVNErrorManager.error(err, SVNLogType.FSFS);
}
if (!revNode.getId().isTxn()) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.FS_NOT_MUTABLE,
"Attempted to set textual contents of an immutable node");
SVNErrorManager.error(err, SVNLogType.FSFS);
}
OutputStream targetOS = null;
InputStream sourceStream = null;
long offset = -1;
long deltaStart = -1;
FSWriteLock txnLock = null;
try {
txnLock = FSWriteLock.getWriteLockForTxn(txnRoot.getTxnID(), txnRoot.getOwner());
txnLock.lock();
File targetFile = txnRoot.getTransactionProtoRevFile();
offset = targetFile.length();
targetOS = SVNFileUtil.openFileForWriting(targetFile, true);
CountingOutputStream revWriter = new CountingOutputStream(targetOS, offset);
FSRepresentation baseRep = revNode.chooseDeltaBase(txnRoot.getOwner());
sourceStream =
FSInputStream.createDeltaStream(new SVNDeltaCombiner(), baseRep, txnRoot.getOwner());
String header;
if (baseRep != null) {
header =
FSRepresentation.REP_DELTA
+ " "
+ baseRep.getRevision()
+ " "
+ baseRep.getOffset()
+ " "
+ baseRep.getSize()
+ "\n";
} else {
header = FSRepresentation.REP_DELTA + "\n";
}
revWriter.write(header.getBytes("UTF-8"));
deltaStart = revWriter.getPosition();
if (dstStream instanceof FSOutputStream) {
FSOutputStream fsOS = (FSOutputStream) dstStream;
fsOS.reset(
revNode, revWriter, targetFile, sourceStream, deltaStart, 0, offset, txnRoot, txnLock);
return dstStream;
}
return new FSOutputStream(
revNode,
revWriter,
targetFile,
sourceStream,
deltaStart,
0,
offset,
txnRoot,
compress,
txnLock);
} catch (IOException ioe) {
SVNFileUtil.closeFile(targetOS);
SVNFileUtil.closeFile(sourceStream);
txnLock.unlock();
FSWriteLock.release(txnLock);
SVNErrorMessage err =
SVNErrorMessage.create(SVNErrorCode.IO_ERROR, ioe.getLocalizedMessage());
SVNErrorManager.error(err, ioe, SVNLogType.FSFS);
} catch (SVNException svne) {
if (txnLock != null) {
txnLock.unlock();
FSWriteLock.release(txnLock);
}
SVNFileUtil.closeFile(targetOS);
SVNFileUtil.closeFile(sourceStream);
throw svne;
}
return null;
}