How to use org.apache.hadoop.hdfs.server.datanode.fsdataset.impl

void getVolumeMap(String bpid, ReplicaMap volumeMap,
         final RamDiskReplicaTracker ramDiskReplicaMap)
  throws IOException {
 getBlockPoolSlice(bpid).getVolumeMap(volumeMap, ramDiskReplicaMap);
}

public void resolveDuplicateReplicas(String bpid, ReplicaInfo memBlockInfo,
  ReplicaInfo diskBlockInfo, ReplicaMap volumeMap) throws IOException {
 getBlockPoolSlice(bpid).resolveDuplicateReplicas(
   memBlockInfo, diskBlockInfo, volumeMap);
}

@Override
void getVolumeMap(String bpid, ReplicaMap volumeMap,
  final RamDiskReplicaTracker ramDiskReplicaMap)
    throws IOException {
 getProvidedBlockPoolSlice(bpid).fetchVolumeMap(volumeMap, ramDiskReplicaMap,
   remoteFS);
}

private void addVolumeFailureInfo(FsVolumeImpl vol) {
 addVolumeFailureInfo(new VolumeFailureInfo(
   vol.getStorageLocation(),
   Time.now(),
   vol.getCapacity()));
}

protected File getLazyPersistDir(String bpid) throws IOException {
 return getBlockPoolSlice(bpid).getLazypersistDir();
}

 public ReplicaInfo activateSavedReplica(String bpid,
   ReplicaInfo replicaInfo, RamDiskReplica replicaState) throws IOException {
  return getBlockPoolSlice(bpid).activateSavedReplica(replicaInfo,
    replicaState);
 }
}

private void setupAsyncLazyPersistThreads() {
 for (FsVolumeImpl v: volumes.getVolumes()){
  setupAsyncLazyPersistThread(v);
 }
}

private boolean ramDiskConfigured() {
 for (FsVolumeImpl v: volumes.getVolumes()){
  if (v.isTransientStorage()) {
   return true;
  }
 }
 return false;
}

long getBlockPoolUsed(String bpid) throws IOException {
 return getBlockPoolSlice(bpid).getDfsUsed();
}

protected File getRbwDir(String bpid) throws IOException {
 return getBlockPoolSlice(bpid).getRbwDir();
}

@Override // FSDatasetMBean
public long getLastVolumeFailureDate() {
 long lastVolumeFailureDate = 0;
 for (VolumeFailureInfo info: volumes.getVolumeFailureInfos()) {
  long failureDate = info.getFailureDate();
  if (failureDate > lastVolumeFailureDate) {
   lastVolumeFailureDate = failureDate;
  }
 }
 return lastVolumeFailureDate;
}

@Override // FSDatasetMBean
public long getEstimatedCapacityLostTotal() {
 long estimatedCapacityLostTotal = 0;
 for (VolumeFailureInfo info: volumes.getVolumeFailureInfos()) {
  estimatedCapacityLostTotal += info.getEstimatedCapacityLost();
 }
 return estimatedCapacityLostTotal;
}

@Override
public void submitBackgroundSyncFileRangeRequest(ExtendedBlock block,
  ReplicaOutputStreams outs, long offset, long nbytes, int flags) {
 FsVolumeImpl fsVolumeImpl = this.getVolume(block);
 asyncDiskService.submitSyncFileRangeRequest(fsVolumeImpl, outs, offset,
   nbytes, flags);
}

void onBlockFileDeletion(String bpid, long value) {
 decDfsUsedAndNumBlocks(bpid, value, true);
 if (isTransientStorage()) {
  dataset.releaseLockedMemory(value, true);
 }
}

public void incrNumBlocks(String bpid) throws IOException {
 getBlockPoolSlice(bpid).incrNumBlocks();
}

@Override
public void releaseLockedMemory(long bytesToRelease) {
 if (isTransientStorage()) {
  dataset.releaseLockedMemory(bytesToRelease, false);
 }
}

/**
 * Release some bytes that we're using.
 *
 * @param count    The number of bytes to release.  We will round this
 *                 up to the page size.
 *
 * @return         The new number of usedBytes.
 */
long release(long count) {
 return usedBytesCount.release(count);
}

@Override
long getBlockPoolUsed(String bpid) throws IOException {
 return getProvidedBlockPoolSlice(bpid).getDfsUsed();
}

@Override
boolean isBPDirEmpty(String bpid) throws IOException {
 return getProvidedBlockPoolSlice(bpid).isEmpty();
}

/**
 * Round up to the OS page size.
 */
long roundUpPageSize(long count) {
 return usedBytesCount.rounder.roundUp(count);
}