Java Snapshot.NO_SNAPSHOT_ID属性代码示例

/**
 * When destroying a reference node (WithName or DstReference), we call this
 * method to identify the snapshot which is the latest snapshot before the
 * reference node's creation. 
 */
static int getPriorSnapshot(INodeReference ref) {
  WithCount wc = (WithCount) ref.getReferredINode();
  WithName wn = null;
  if (ref instanceof DstReference) {
    wn = wc.getLastWithName();
  } else if (ref instanceof WithName) {
    wn = wc.getPriorWithName((WithName) ref);
  }
  if (wn != null) {
    INode referred = wc.getReferredINode();
    if (referred.isFile() && referred.asFile().isWithSnapshot()) {
      return referred.asFile().getDiffs().getPrior(wn.lastSnapshotId);
    } else if (referred.isDirectory()) {
      DirectoryWithSnapshotFeature sf = referred.asDirectory()
          .getDirectoryWithSnapshotFeature();
      if (sf != null) {
        return sf.getDiffs().getPrior(wn.lastSnapshotId);
      }
    }
  }
  return Snapshot.NO_SNAPSHOT_ID;
}
 

/** Is this inode in the latest snapshot? */
public final boolean isInLatestSnapshot(final int latestSnapshotId) {
  if (latestSnapshotId == Snapshot.CURRENT_STATE_ID || latestSnapshotId == Snapshot.NO_SNAPSHOT_ID) {
    return false;
  }
  // if parent is a reference node, parent must be a renamed node. We can 
  // stop the check at the reference node.
  if (parent != null && parent.isReference()) {
    return true;
  }
  final INodeDirectory parentDir = getParent();
  if (parentDir == null) { // root
    return true;
  }
  if (!parentDir.isInLatestSnapshot(latestSnapshotId)) {
    return false;
  }
  final INode child = parentDir.getChild(getLocalNameBytes(), latestSnapshotId);
  if (this == child) {
    return true;
  }
  return child != null && child.isReference() &&
      this == child.asReference().getReferredINode();
}
 

/** Call cleanSubtree(..) recursively down the subtree. */
public QuotaCounts cleanSubtreeRecursively(final BlockStoragePolicySuite bsps,
    final int snapshot,
    int prior, final BlocksMapUpdateInfo collectedBlocks,
    final List<INode> removedINodes, final Map<INode, INode> excludedNodes) {
  QuotaCounts counts = new QuotaCounts.Builder().build();
  // in case of deletion snapshot, since this call happens after we modify
  // the diff list, the snapshot to be deleted has been combined or renamed
  // to its latest previous snapshot. (besides, we also need to consider nodes
  // created after prior but before snapshot. this will be done in 
  // DirectoryWithSnapshotFeature)
  int s = snapshot != Snapshot.CURRENT_STATE_ID
      && prior != Snapshot.NO_SNAPSHOT_ID ? prior : snapshot;
  for (INode child : getChildrenList(s)) {
    if (snapshot != Snapshot.CURRENT_STATE_ID && excludedNodes != null
        && excludedNodes.containsKey(child)) {
      continue;
    } else {
      QuotaCounts childCounts = child.cleanSubtree(bsps, snapshot, prior,
          collectedBlocks, removedINodes);
      counts.add(childCounts);
    }
  }
  return counts;
}
 

@Override
public void cleanSubtree(ReclaimContext reclaimContext, int snapshot,
    int prior) {
  if (snapshot == Snapshot.CURRENT_STATE_ID
      && prior == Snapshot.NO_SNAPSHOT_ID) {
    destroyAndCollectBlocks(reclaimContext);
  } else {
    // if prior is NO_SNAPSHOT_ID, we need to check snapshot belonging to 
    // the previous WithName instance
    if (prior == Snapshot.NO_SNAPSHOT_ID) {
      prior = getPriorSnapshot(this);
    }
    // if prior is not NO_SNAPSHOT_ID, and prior is not before the
    // to-be-deleted snapshot, we can quit here and leave the snapshot
    // deletion work to the src tree of rename
    if (snapshot != Snapshot.CURRENT_STATE_ID
        && prior != Snapshot.NO_SNAPSHOT_ID
        && Snapshot.ID_INTEGER_COMPARATOR.compare(snapshot, prior) <= 0) {
      return;
    }
    getReferredINode().cleanSubtree(reclaimContext, snapshot, prior);
  }
}
 

/** Is this inode in the latest snapshot? */
public final boolean isInLatestSnapshot(final int latestSnapshotId) {
  if (latestSnapshotId == Snapshot.CURRENT_STATE_ID ||
      latestSnapshotId == Snapshot.NO_SNAPSHOT_ID) {
    return false;
  }
  // if parent is a reference node, parent must be a renamed node. We can 
  // stop the check at the reference node.
  if (parent != null && parent.isReference()) {
    return true;
  }
  final INodeDirectory parentDir = getParent();
  if (parentDir == null) { // root
    return true;
  }
  if (!parentDir.isInLatestSnapshot(latestSnapshotId)) {
    return false;
  }
  final INode child = parentDir.getChild(getLocalNameBytes(), latestSnapshotId);
  if (this == child) {
    return true;
  }
  return child != null && child.isReference() &&
      this == child.asReference().getReferredINode();
}
 

/** Call cleanSubtree(..) recursively down the subtree. */
public void cleanSubtreeRecursively(
    ReclaimContext reclaimContext, final int snapshot, int prior,
    final Map<INode, INode> excludedNodes) {
  // in case of deletion snapshot, since this call happens after we modify
  // the diff list, the snapshot to be deleted has been combined or renamed
  // to its latest previous snapshot. (besides, we also need to consider nodes
  // created after prior but before snapshot. this will be done in 
  // DirectoryWithSnapshotFeature)
  int s = snapshot != Snapshot.CURRENT_STATE_ID
      && prior != Snapshot.NO_SNAPSHOT_ID ? prior : snapshot;
  for (INode child : getChildrenList(s)) {
    if (snapshot == Snapshot.CURRENT_STATE_ID || excludedNodes == null ||
        !excludedNodes.containsKey(child)) {
      child.cleanSubtree(reclaimContext, snapshot, prior);
    }
  }
}
 

@Override
public QuotaCounts cleanSubtree(BlockStoragePolicySuite bsps,
    final int snapshotId, int priorSnapshotId,
    final BlocksMapUpdateInfo collectedBlocks,
    final List<INode> removedINodes) {
  if (snapshotId == Snapshot.CURRENT_STATE_ID
      && priorSnapshotId == Snapshot.NO_SNAPSHOT_ID) {
    destroyAndCollectBlocks(bsps, collectedBlocks, removedINodes);
  }
  return new QuotaCounts.Builder().nameSpace(1).build();
}
 

@Override
public QuotaCounts cleanSubtree(BlockStoragePolicySuite bsps,
    final int snapshot, int prior, final BlocksMapUpdateInfo collectedBlocks,
    final List<INode> removedINodes) {
  // since WithName node resides in deleted list acting as a snapshot copy,
  // the parameter snapshot must be non-null
  Preconditions.checkArgument(snapshot != Snapshot.CURRENT_STATE_ID);
  // if prior is NO_SNAPSHOT_ID, we need to check snapshot belonging to the
  // previous WithName instance
  if (prior == Snapshot.NO_SNAPSHOT_ID) {
    prior = getPriorSnapshot(this);
  }
  
  if (prior != Snapshot.NO_SNAPSHOT_ID
      && Snapshot.ID_INTEGER_COMPARATOR.compare(snapshot, prior) <= 0) {
    return new QuotaCounts.Builder().build();
  }

  QuotaCounts counts = getReferredINode().cleanSubtree(bsps, snapshot, prior,
      collectedBlocks, removedINodes);
  INodeReference ref = getReferredINode().getParentReference();
  if (ref != null) {
    try {
      ref.addSpaceConsumed(counts.negation(), true);
    } catch (QuotaExceededException e) {
      Log.warn("Should not have QuotaExceededException");
    }
  }
  
  if (snapshot < lastSnapshotId) {
    // for a WithName node, when we compute its quota usage, we only count
    // in all the nodes existing at the time of the corresponding rename op.
    // Thus if we are deleting a snapshot before/at the snapshot associated 
    // with lastSnapshotId, we do not need to update the quota upwards.
    counts = new QuotaCounts.Builder().build();
  }
  return counts;
}
 

@Override
public void destroyAndCollectBlocks(BlockStoragePolicySuite bsps,
    BlocksMapUpdateInfo collectedBlocks,
    final List<INode> removedINodes) {
  int snapshot = getSelfSnapshot();
  if (removeReference(this) <= 0) {
    getReferredINode().destroyAndCollectBlocks(bsps, collectedBlocks,
        removedINodes);
  } else {
    int prior = getPriorSnapshot(this);
    INode referred = getReferredINode().asReference().getReferredINode();
    
    if (snapshot != Snapshot.NO_SNAPSHOT_ID) {
      if (prior != Snapshot.NO_SNAPSHOT_ID && snapshot <= prior) {
        // the snapshot to be deleted has been deleted while traversing 
        // the src tree of the previous rename operation. This usually 
        // happens when rename's src and dst are under the same 
        // snapshottable directory. E.g., the following operation sequence:
        // 1. create snapshot s1 on /test
        // 2. rename /test/foo/bar to /test/foo2/bar
        // 3. create snapshot s2 on /test
        // 4. rename foo2 again
        // 5. delete snapshot s2
        return;
      }
      try {
        QuotaCounts counts = referred.cleanSubtree(bsps, snapshot, prior,
            collectedBlocks, removedINodes);
        INodeReference ref = getReferredINode().getParentReference();
        if (ref != null) {
          ref.addSpaceConsumed(counts.negation(), true);
        }
      } catch (QuotaExceededException e) {
        LOG.error("should not exceed quota while snapshot deletion", e);
      }
    }
  }
}
 

private int getSelfSnapshot() {
  INode referred = getReferredINode().asReference().getReferredINode();
  int snapshot = Snapshot.NO_SNAPSHOT_ID;
  if (referred.isFile() && referred.asFile().isWithSnapshot()) {
    snapshot = referred.asFile().getDiffs().getPrior(lastSnapshotId);
  } else if (referred.isDirectory()) {
    DirectoryWithSnapshotFeature sf = referred.asDirectory()
        .getDirectoryWithSnapshotFeature();
    if (sf != null) {
      snapshot = sf.getDiffs().getPrior(lastSnapshotId);
    }
  }
  return snapshot;
}
 

/**
 * Search for the given INode in the children list and the deleted lists of
 * snapshots.
 * @return {@link Snapshot#CURRENT_STATE_ID} if the inode is in the children
 * list; {@link Snapshot#NO_SNAPSHOT_ID} if the inode is neither in the
 * children list nor in any snapshot; otherwise the snapshot id of the
 * corresponding snapshot diff list.
 */
public int searchChild(INode inode) {
  INode child = getChild(inode.getLocalNameBytes(), Snapshot.CURRENT_STATE_ID);
  if (child != inode) {
    // inode is not in parent's children list, thus inode must be in
    // snapshot. identify the snapshot id and later add it into the path
    DirectoryDiffList diffs = getDiffs();
    if (diffs == null) {
      return Snapshot.NO_SNAPSHOT_ID;
    }
    return diffs.findSnapshotDeleted(inode);
  } else {
    return Snapshot.CURRENT_STATE_ID;
  }
}
 

@Override
public void cleanSubtree(ReclaimContext reclaimContext, final int snapshotId,
    int priorSnapshotId) {
  if (snapshotId == Snapshot.CURRENT_STATE_ID
      && priorSnapshotId == Snapshot.NO_SNAPSHOT_ID) {
    destroyAndCollectBlocks(reclaimContext);
  }
}
 

@Override
public void destroyAndCollectBlocks(ReclaimContext reclaimContext) {
  int snapshot = getSelfSnapshot();
  reclaimContext.quotaDelta().add(computeQuotaUsage(reclaimContext.bsps));
  if (removeReference(this) <= 0) {
    getReferredINode().destroyAndCollectBlocks(reclaimContext.getCopy());
  } else {
    int prior = getPriorSnapshot(this);
    INode referred = getReferredINode().asReference().getReferredINode();

    if (snapshot != Snapshot.NO_SNAPSHOT_ID) {
      if (prior != Snapshot.NO_SNAPSHOT_ID && snapshot <= prior) {
        // the snapshot to be deleted has been deleted while traversing 
        // the src tree of the previous rename operation. This usually 
        // happens when rename's src and dst are under the same 
        // snapshottable directory. E.g., the following operation sequence:
        // 1. create snapshot s1 on /test
        // 2. rename /test/foo/bar to /test/foo2/bar
        // 3. create snapshot s2 on /test
        // 4. rename foo2 again
        // 5. delete snapshot s2
        return;
      }
      ReclaimContext newCtx = reclaimContext.getCopy();
      referred.cleanSubtree(newCtx, snapshot, prior);
      INodeReference ref = getReferredINode().getParentReference();
      if (ref != null) {
        // we need to update the quota usage along the parent path from ref
        reclaimContext.quotaDelta().addUpdatePath(ref,
            newCtx.quotaDelta().getCountsCopy());
      }
    }
  }
}
 

@Override
public void cleanSubtree(ReclaimContext reclaimContext, final int snapshotId,
    int priorSnapshotId) {
  DirectoryWithSnapshotFeature sf = getDirectoryWithSnapshotFeature();
  // there is snapshot data
  if (sf != null) {
    sf.cleanDirectory(reclaimContext, this, snapshotId, priorSnapshotId);
  } else {
    // there is no snapshot data
    if (priorSnapshotId == Snapshot.NO_SNAPSHOT_ID &&
        snapshotId == Snapshot.CURRENT_STATE_ID) {
      // destroy the whole subtree and collect blocks that should be deleted
      destroyAndCollectBlocks(reclaimContext);
    } else {
      // make a copy the quota delta
      QuotaCounts old = reclaimContext.quotaDelta().getCountsCopy();
      // process recursively down the subtree
      cleanSubtreeRecursively(reclaimContext, snapshotId, priorSnapshotId,
          null);
      QuotaCounts current = reclaimContext.quotaDelta().getCountsCopy();
      current.subtract(old);
      if (isQuotaSet()) {
        reclaimContext.quotaDelta().addQuotaDirUpdate(this, current);
      }
    }
  }
}