Java Code Examples for org.apache.hadoop.hdfs.server.namenode.snapshot.Snapshot#CURRENT_STATE_ID

private int getSelfSnapshot(final int prior) {
  WithCount wc = (WithCount) getReferredINode().asReference();
  INode referred = wc.getReferredINode();
  int lastSnapshot = Snapshot.CURRENT_STATE_ID;
  if (referred.isFile() && referred.asFile().isWithSnapshot()) {
    lastSnapshot = referred.asFile().getDiffs().getLastSnapshotId();
  } else if (referred.isDirectory()) {
    DirectoryWithSnapshotFeature sf = referred.asDirectory()
        .getDirectoryWithSnapshotFeature();
    if (sf != null) {
      lastSnapshot = sf.getLastSnapshotId();
    }
  }
  if (lastSnapshot != Snapshot.CURRENT_STATE_ID && lastSnapshot != prior) {
    return lastSnapshot;
  } else {
    return Snapshot.CURRENT_STATE_ID;
  }
}
 

/**
 * Undo the rename operation for the dst tree, i.e., if the rename operation
 * (with OVERWRITE option) removes a file/dir from the dst tree, add it back
 * and delete possible record in the deleted list.  
 */
public void undoRename4DstParent(final BlockStoragePolicySuite bsps,
    final INode deletedChild,
    int latestSnapshotId) throws QuotaExceededException {
  DirectoryWithSnapshotFeature sf = getDirectoryWithSnapshotFeature();
  Preconditions.checkState(sf != null,
      "Directory does not have snapshot feature");
  boolean removeDeletedChild = sf.getDiffs().removeChild(ListType.DELETED,
      deletedChild);
  int sid = removeDeletedChild ? Snapshot.CURRENT_STATE_ID : latestSnapshotId;
  final boolean added = addChild(deletedChild, true, sid);
  // update quota usage if adding is successfully and the old child has not
  // been stored in deleted list before
  if (added && !removeDeletedChild) {
    final QuotaCounts counts = deletedChild.computeQuotaUsage(bsps);
    addSpaceConsumed(counts, false);

  }
}
 

/** 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();
}
 

@Override
final FsPermission getFsPermission(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getFsPermission();
  }

  return new FsPermission(getFsPermissionShort());
}
 

/**
 * @param name the name of the child
 * @param snapshotId
 *          if it is not {@link Snapshot#CURRENT_STATE_ID}, get the result
 *          from the corresponding snapshot; otherwise, get the result from
 *          the current directory.
 * @return the child inode.
 */
public INode getChild(byte[] name, int snapshotId) {
  DirectoryWithSnapshotFeature sf;
  if (snapshotId == Snapshot.CURRENT_STATE_ID || 
      (sf = getDirectoryWithSnapshotFeature()) == null) {
    ReadOnlyList<INode> c = getCurrentChildrenList();
    final int i = ReadOnlyList.Util.binarySearch(c, name);
    return i < 0 ? null : c.get(i);
  }
  
  return sf.getChild(this, name, snapshotId);
}
 

/**
 * Save the child to the latest snapshot.
 * 
 * @return the child inode, which may be replaced.
 */
public INode saveChild2Snapshot(final INode child, final int latestSnapshotId,
    final INode snapshotCopy) {
  if (latestSnapshotId == Snapshot.CURRENT_STATE_ID) {
    return child;
  }
  
  // add snapshot feature if necessary
  DirectoryWithSnapshotFeature sf = getDirectoryWithSnapshotFeature();
  if (sf == null) {
    sf = this.addSnapshotFeature(null);
  }
  return sf.saveChild2Snapshot(this, child, latestSnapshotId, snapshotCopy);
}
 

/**
 * Save the child to the latest snapshot.
 * 
 * @return the child inode, which may be replaced.
 */
public INode saveChild2Snapshot(final INode child, final int latestSnapshotId,
    final INode snapshotCopy) {
  if (latestSnapshotId == Snapshot.CURRENT_STATE_ID) {
    return child;
  }
  
  // add snapshot feature if necessary
  DirectoryWithSnapshotFeature sf = getDirectoryWithSnapshotFeature();
  if (sf == null) {
    sf = this.addSnapshotFeature(null);
  }
  return sf.saveChild2Snapshot(this, child, latestSnapshotId, snapshotCopy);
}
 

/**
 * 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
final FsPermission getFsPermission(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getFsPermission();
  }

  return new FsPermission(getFsPermissionShort());
}
 

@Override
final long getModificationTime(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getModificationTime();
  }

  return this.modificationTime;
}
 

@Override
public final AclFeature getAclFeature(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getAclFeature();
  }

  return getFeature(AclFeature.class);
}
 

@Override
final String getGroupName(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getGroupName();
  }
  return PermissionStatusFormat.getGroup(permission);
}
 

@Override
final String getUserName(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getUserName();
  }
  return PermissionStatusFormat.getUser(permission);
}
 

@Override
XAttrFeature getXAttrFeature(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getXAttrFeature();
  }

  return getFeature(XAttrFeature.class);
}
 

@Override
public QuotaCounts cleanSubtree(BlockStoragePolicySuite bsps, int snapshot, int prior,
    BlocksMapUpdateInfo collectedBlocks, List<INode> removedINodes) {
  if (snapshot == Snapshot.CURRENT_STATE_ID
      && prior == Snapshot.NO_SNAPSHOT_ID) {
    QuotaCounts counts = new QuotaCounts.Builder().build();
    this.computeQuotaUsage(bsps, counts, true);
    destroyAndCollectBlocks(bsps, collectedBlocks, removedINodes);
    return counts;
  } 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 new QuotaCounts.Builder().build();
    }
    return getReferredINode().cleanSubtree(bsps, snapshot, prior,
        collectedBlocks, removedINodes);
  }
}
 

@Override
public final AclFeature getAclFeature(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getAclFeature();
  }

  return getFeature(AclFeature.class);
}
 

@Override
final long getModificationTime(int snapshotId) {
  if (snapshotId != Snapshot.CURRENT_STATE_ID) {
    return getSnapshotINode(snapshotId).getModificationTime();
  }

  return this.modificationTime;
}
 

public int getDstSnapshotId() {
  return Snapshot.CURRENT_STATE_ID;
}
 

RenameOperation(FSDirectory fsd, String src, String dst,
                INodesInPath srcIIP, INodesInPath dstIIP)
    throws QuotaExceededException {
  this.fsd = fsd;
  this.src = src;
  this.dst = dst;
  this.srcIIP = srcIIP;
  this.dstIIP = dstIIP;
  this.srcParentIIP = srcIIP.getParentINodesInPath();
  this.dstParentIIP = dstIIP.getParentINodesInPath();

  BlockStoragePolicySuite bsps = fsd.getBlockStoragePolicySuite();
  srcChild = this.srcIIP.getLastINode();
  srcChildName = srcChild.getLocalNameBytes();
  final int srcLatestSnapshotId = srcIIP.getLatestSnapshotId();
  isSrcInSnapshot = srcChild.isInLatestSnapshot(srcLatestSnapshotId);
  srcChildIsReference = srcChild.isReference();
  srcParent = this.srcIIP.getINode(-2).asDirectory();

  // Record the snapshot on srcChild. After the rename, before any new
  // snapshot is taken on the dst tree, changes will be recorded in the
  // latest snapshot of the src tree.
  if (isSrcInSnapshot) {
    srcChild.recordModification(srcLatestSnapshotId);
  }

  // check srcChild for reference
  srcRefDstSnapshot = srcChildIsReference ?
      srcChild.asReference().getDstSnapshotId() : Snapshot.CURRENT_STATE_ID;
  oldSrcCounts = new QuotaCounts.Builder().build();
  if (isSrcInSnapshot) {
    final INodeReference.WithName withName = srcParent
        .replaceChild4ReferenceWithName(srcChild, srcLatestSnapshotId);
    withCount = (INodeReference.WithCount) withName.getReferredINode();
    srcChild = withName;
    this.srcIIP = INodesInPath.replace(srcIIP, srcIIP.length() - 1,
        srcChild);
    // get the counts before rename
    withCount.getReferredINode().computeQuotaUsage(bsps, oldSrcCounts, true);
  } else if (srcChildIsReference) {
    // srcChild is reference but srcChild is not in latest snapshot
    withCount = (INodeReference.WithCount) srcChild.asReference()
        .getReferredINode();
  } else {
    withCount = null;
  }
}
 

/**
 * @param snapshotId
 *          if it is not {@link Snapshot#CURRENT_STATE_ID}, get the result
 *          from the corresponding snapshot; otherwise, get the result from
 *          the current directory.
 * @return the current children list if the specified snapshot is null;
 *         otherwise, return the children list corresponding to the snapshot.
 *         Note that the returned list is never null.
 */
public ReadOnlyList<INode> getChildrenList(final int snapshotId) {
  DirectoryWithSnapshotFeature sf;
  if (snapshotId == Snapshot.CURRENT_STATE_ID
      || (sf = this.getDirectoryWithSnapshotFeature()) == null) {
    return getCurrentChildrenList();
  }
  return sf.getChildrenList(this, snapshotId);
}