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;
 }
Example #2
0
 @Override
 public void close() throws IOException {
   if (!finished) {
     finish();
   }
   stream.close();
 }
Example #3
0
  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");
  }
Example #4
0
 /**
  * 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);
 }
Example #6
0
  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());
  }
Example #7
0
 @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;
 }
Example #8
0
 public long getUnpaddedSize() {
   return headerSize + outCounted.getSize() + check.getSize();
 }
Example #9
0
 /**
  * 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);
 }
Example #10
0
  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);
    }
  }
Example #11
0
  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;
  }