public boolean hasNoLiveValues() { return this.totalLiveCount.get() <= 0 // if we have an unrecoveredRegion then we don't know how many liveValues we // have && this.unrecoveredRegionCount.get() == 0 && !getParent().isOfflineCompacting(); }
/** * Schedule a task to create a krf asynchronously */ protected void createKrfAsync() { getParent().executeDiskStoreTask(new Runnable() { @Override public void run() { createKrf(false); } }); }
private InternalCache getInternalCache() { return getParent().getCache(); }
private void copyForwardForOfflineCompact(long oplogKeyId, byte[] keyBytes, byte[] valueBytes, byte userBits, long drId, VersionTag tag) { try { basicCopyForwardForOfflineCompact(oplogKeyId, keyBytes, valueBytes, userBits, drId, tag); } catch (IOException ex) { getParent().getCancelCriterion().checkCancelInProgress(ex); throw new DiskAccessException( String.format("Failed writing key to %s", this.diskFile.getPath()), ex, getParent()); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); getParent().getCancelCriterion().checkCancelInProgress(ie); throw new DiskAccessException( String.format( "Failed writing key to %s due to failure in acquiring read lock for asynch writing", this.diskFile.getPath()), ie, getParent()); } }
/** * Write an RVV record containing all of the live disk regions. */ private void writeRVVRecord(OplogFile olf, boolean writeGCRVV) throws IOException { writeRVVRecord(olf, getParent().getAllDiskRegions(), writeGCRVV); }
public void flushAll(boolean skipDrf, boolean doSync) { try { // TODO: if skipDrf then only need to do drf if crf has flushable data flush(this.drf, doSync); flush(this.crf, doSync); } catch (IOException ex) { getParent().getCancelCriterion().checkCancelInProgress(ex); throw new DiskAccessException( String.format("Failed writing key to %s", this.diskFile.getPath()), ex, getParent()); } }
public boolean hasKrf() { return getParent().getDiskInitFile().hasKrf(this.oplogId); }
/** * @throws DiskAccessException if this file does not belong to our parent */ private void readDiskStoreRecord(DataInput dis, File f) throws IOException { long leastSigBits = dis.readLong(); long mostSigBits = dis.readLong(); DiskStoreID readDSID = new DiskStoreID(mostSigBits, leastSigBits); if (logger.isTraceEnabled(LogMarker.PERSIST_RECOVERY_VERBOSE)) { logger.trace(LogMarker.PERSIST_RECOVERY_VERBOSE, "diskStoreId={}", readDSID); } readEndOfRecord(dis); DiskStoreID dsid = getParent().getDiskStoreID(); if (!readDSID.equals(dsid)) { throw new DiskAccessException("The oplog file \"" + f + "\" does not belong to the init file \"" + getParent().getInitFile() + "\".", getParent()); } }
private void handleEmptyAndOldest(boolean calledByCompactor) { if (!calledByCompactor && logger.isDebugEnabled()) { logger.debug( "Deleting oplog early because it is empty. It is for disk store {} and has oplog#{}", getParent().getName(), oplogId); } destroy(); getOplogSet().destroyOldestReadyToCompact(); }
private void validateValue(byte[] valueBytes, byte userBits, Version version, ByteArrayDataInput in) { if (getParent().isValidating()) { if (EntryBits.isSerialized(userBits)) { // make sure values are deserializable if (!PdxWriterImpl.isPdx(valueBytes)) { // fix bug 43011 try { DiskEntry.Helper.readSerializedValue(valueBytes, version, in, true, getParent().getCache()); } catch (SerializationException ex) { if (logger.isDebugEnabled()) { logger.debug("Could not deserialize recovered value: {}", ex.getCause(), ex); } } } } } }
/** * A check to confirm that the oplog has been closed because of the cache being closed * */ private void checkClosed() { getParent().getCancelCriterion().checkCancelInProgress(null); if (!this.closed) { return; } throw new OplogCancelledException("This Oplog has been closed."); }
private Version readProductVersionRecord(DataInput dis, File f) throws IOException { Version recoveredGFVersion; short ver = Version.readOrdinal(dis); try { recoveredGFVersion = Version.fromOrdinal(ver, false); } catch (UnsupportedVersionException e) { throw new DiskAccessException( String.format("Unknown version ordinal %s found when recovering Oplogs", ver), e, getParent()); } if (logger.isTraceEnabled(LogMarker.PERSIST_RECOVERY_VERBOSE)) { logger.trace(LogMarker.PERSIST_RECOVERY_VERBOSE, "version={}", recoveredGFVersion); } readEndOfRecord(dis); return recoveredGFVersion; }
private Object deserializeKey(byte[] keyBytes, final Version version, final ByteArrayDataInput in) { if (!getParent().isOffline() || !PdxWriterImpl.isPdx(keyBytes)) { return EntryEventImpl.deserialize(keyBytes, version, in); } else { return new RawByteKey(keyBytes); } }
private synchronized VersionTag createDummyTag(DiskRecoveryStore drs) { DiskStoreID member = getParent().getDiskStoreID(); int memberid = getParent().getDiskInitFile().getOrCreateCanonicalId(member); long regionVersion = drs.getVersionForMember(member); VersionTag vt = VersionTag.create(member); vt.setEntryVersion(1); vt.setRegionVersion(regionVersion + 1); vt.setMemberID(member); vt.setVersionTimeStamp(getParent().getCache().cacheTimeMillis()); vt.setDistributedSystemId(-1); return vt; }
private boolean isLruValueRecoveryDisabled(DiskRecoveryStore store) { return !store.getDiskStore().isOffline() && !getParent().RECOVER_LRU_VALUES && !store.getEvictionAttributes().getAlgorithm().isNone(); }
public void deleteCRF() { oplogSet.crfDelete(this.oplogId); if (!getInternalCache().getBackupService().deferCrfDelete(getParent(), this)) { deleteCRFFileOnly(); } }
public void deleteDRF() { getOplogSet().drfDelete(this.oplogId); if (!getInternalCache().getBackupService().deferDrfDelete(getParent(), this)) { deleteDRFFileOnly(); } }
private void handleEmpty(boolean calledByCompactor) { lockCompactor(); try { if (!calledByCompactor) { logger.info("Closing {} early since it is empty. It is for disk store {}.", new Object[] {getParent().getName(), toString()}); } cancelKrf(); close(); deleteFiles(getHasDeletes()); } finally { unlockCompactor(); } }
private void serializeVersionTag(int entryVersion, long regionVersion, VersionSource versionMember, long timestamp, int dsId, DataOutput out) throws IOException { int memberId = getParent().getDiskInitFile().getOrCreateCanonicalId(versionMember); InternalDataSerializer.writeSignedVL(entryVersion, out); InternalDataSerializer.writeUnsignedVL(regionVersion, out); InternalDataSerializer.writeUnsignedVL(memberId, out); InternalDataSerializer.writeUnsignedVL(timestamp, out); InternalDataSerializer.writeSignedVL(dsId, out); }
private void writeDiskStoreRecord(OplogFile olf, OPLOG_TYPE type) throws IOException { this.opState = new OpState(); this.opState.initialize(type); writeOpLogBytes(olf, false, true); olf.currSize += getOpStateSize(); this.dirHolder.incrementTotalOplogSize(getOpStateSize()); clearOpState(); this.opState.initialize(getParent().getDiskStoreID()); writeOpLogBytes(olf, false, true); // fix for bug 41928 olf.currSize += getOpStateSize(); this.dirHolder.incrementTotalOplogSize(getOpStateSize()); }