private ContentClaim createClaim(final String container, final String section, final String identifier, final Long offset) { if (container == null || section == null || identifier == null) { return null; } final ResourceClaim resourceClaim = resourceClaimManager.newResourceClaim(container, section, identifier, false, false); return new StandardContentClaim(resourceClaim, offset == null ? 0L : offset.longValue()); }
if (scc.getLength() < 0) { scc.setLength(0L); final long resourceClaimLength = scc.getOffset() + scc.getLength(); if (recycle && resourceClaimLength < maxAppendableClaimLength) { final ClaimLengthPair pair = new ClaimLengthPair(scc.getResourceClaim(), resourceClaimLength); final boolean enqueued = writableClaimStreams.get(scc.getResourceClaim()) != null && writableClaimQueue.offer(pair); writableClaimStreams.remove(scc.getResourceClaim()); resourceClaimManager.freeze(scc.getResourceClaim()); resourceClaimManager.freeze(scc.getResourceClaim()); writableClaimQueue.remove(new ClaimLengthPair(scc.getResourceClaim(), resourceClaimLength));
final StandardContentClaim contentClaim = new StandardContentClaim(resourceClaim, resourceOffset); contentClaim.setLength(resourceLength);
@Override public void write(final int b) throws IOException { bcos.write(b); bytesWritten++; scc.setLength(initialLength + bytesWritten); }
ByteCountingOutputStream claimStream = writableClaimStreams.get(scc.getResourceClaim()); final int initialLength = append ? (int) Math.max(0, scc.getLength()) : 0;
@Override public void purge() { for (final ContentClaim claim : claimMap.keySet()) { claimManager.decrementClaimantCount(resolveClaim(claim).getResourceClaim()); final ContentClaim backup = getBackupClaim(claim); if (backup != null) { getBackupRepository().remove(backup); } } }
final long initialLength = Math.max(0L, scc.getLength());
final StandardContentClaim claim = new StandardContentClaim(resourceClaim, resourceOffset); claim.setLength(resourceLength);
@Override public void write(byte[] b, int off, int len) throws IOException { bcos.write(b, off, len); bytesWritten += len; scc.setLength(initialLength + bytesWritten); }
@Override public int incrementClaimaintCount(final ContentClaim claim) { if (claim == null) { return 0; } final ContentClaim backupClaim = getBackupClaim(claim); if (backupClaim == null) { return claimManager.incrementClaimantCount(resolveClaim(claim).getResourceClaim()); } else { return getBackupRepository().incrementClaimaintCount(backupClaim); } }
public static ContentClaim getContentClaim(final Record claimRecord, final ResourceClaimManager resourceClaimManager) { final Record resourceClaimRecord = (Record) claimRecord.getFieldValue(ContentClaimSchema.RESOURCE_CLAIM); final String container = (String) resourceClaimRecord.getFieldValue(ContentClaimSchema.CLAIM_CONTAINER); final String section = (String) resourceClaimRecord.getFieldValue(ContentClaimSchema.CLAIM_SECTION); final String identifier = (String) resourceClaimRecord.getFieldValue(ContentClaimSchema.CLAIM_IDENTIFIER); final Boolean lossTolerant = (Boolean) resourceClaimRecord.getFieldValue(ContentClaimSchema.LOSS_TOLERANT); final Long length = (Long) claimRecord.getFieldValue(ContentClaimSchema.CONTENT_CLAIM_LENGTH); final Long resourceOffset = (Long) claimRecord.getFieldValue(ContentClaimSchema.RESOURCE_CLAIM_OFFSET); // Make sure that we preserve the existing ResourceClaim, if there is already one held by the Resource Claim Manager // because we need to honor its determination of whether or not the claim is writable. If the Resource Claim Manager // does not have a copy of this Resource Claim, then we can go ahead and just create one and assume that it is not // writable (because if it were writable, then the Resource Claim Manager would know about it). ResourceClaim resourceClaim = resourceClaimManager.getResourceClaim(container, section, identifier); if (resourceClaim == null) { resourceClaim = resourceClaimManager.newResourceClaim(container, section, identifier, lossTolerant, false); } final StandardContentClaim contentClaim = new StandardContentClaim(resourceClaim, resourceOffset); contentClaim.setLength(length); return contentClaim; }
@Override public synchronized void write(final int b) throws IOException { if (closed) { throw new IOException("Stream is closed"); } try { bcos.write(b); } catch (final IOException ioe) { recycle = false; throw new IOException("Failed to write to " + this, ioe); } bytesWritten++; scc.setLength(bytesWritten + initialLength); }
private ContentClaim createLossTolerant() { final long id = idGenerator.getAndIncrement(); final ResourceClaim resourceClaim = claimManager.newResourceClaim(CONTAINER_NAME, "section", String.valueOf(id), true, false); final ContentClaim claim = new StandardContentClaim(resourceClaim, 0L); final ContentBlock contentBlock = new ContentBlock(claim, repoSize); claimManager.incrementClaimantCount(resourceClaim, true); claimMap.put(claim, contentBlock); logger.debug("Created {} and mapped to {}", claim, contentBlock); return claim; }
@Override public int decrementClaimantCount(final ContentClaim claim) { if (claim == null) { return 0; } final ContentClaim backupClaim = getBackupClaim(claim); if (backupClaim == null) { return claimManager.decrementClaimantCount(resolveClaim(claim).getResourceClaim()); } else { return getBackupRepository().decrementClaimantCount(backupClaim); } }
final StandardContentClaim contentClaim = new StandardContentClaim(resourceClaim, claimOffset); contentClaim.setLength(event.getPreviousFileSize() == null ? -1L : event.getPreviousFileSize());
@Override public synchronized void write(final byte[] b) throws IOException { if (closed) { throw new IOException("Stream is closed"); } try { bcos.write(b); } catch (final IOException ioe) { recycle = false; throw new IOException("Failed to write to " + this, ioe); } bytesWritten += b.length; scc.setLength(bytesWritten + initialLength); }
final StandardContentClaim scc = new StandardContentClaim(resourceClaim, resourceOffset); return scc;
@Override public int getClaimantCount(final ContentClaim claim) { if (claim == null) { return 0; } final ContentClaim backupClaim = getBackupClaim(claim); if (backupClaim == null) { return claimManager.getClaimantCount(resolveClaim(claim).getResourceClaim()); } else { return getBackupRepository().getClaimantCount(backupClaim); } }
final StandardContentClaim contentClaim = new StandardContentClaim(resourceClaim, resourceOffset); contentClaim.setLength(resourceLength);
@Override public synchronized void write(final byte[] b, final int off, final int len) throws IOException { if (closed) { throw new IOException("Stream is closed"); } try { bcos.write(b, off, len); } catch (final IOException ioe) { recycle = false; throw new IOException("Failed to write to " + this, ioe); } bytesWritten += len; scc.setLength(bytesWritten + initialLength); }