Java XAttrSetFlag类代码示例

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
@Override
public void setXAttrs(Map<String, List<XAttr>> xAttrsToSet, EnumSet<XAttrSetFlag> flag)
    throws IOException {

  SetXAttrsRequestProto.Builder builder = SetXAttrsRequestProto.newBuilder();
  for (String src : xAttrsToSet.keySet()) {
    List<XAttr> xAttrs = xAttrsToSet.get(src);
    SetXAttrSingleRequestProto singleReq = SetXAttrSingleRequestProto.newBuilder()
        .setSrc(src)
        .addAllXAttr(NuCypherExtPBHelperClient.convertXAttrProto(xAttrs))
        .build();
    builder.addXAttrsToSet(singleReq);
  }
  SetXAttrsRequestProto req = builder.setFlag(NuCypherExtPBHelperClient.convert(flag)).build();
  try {
    rpcProxy.setXAttrs(null, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
public void setXAttr(String src, String name, byte[] value, 
    EnumSet<XAttrSetFlag> flag) throws IOException {
  checkOpen();
  TraceScope scope = getPathTraceScope("setXAttr", src);
  try {
    namenode.setXAttr(src, XAttrHelper.buildXAttr(name, value), flag);
  } catch (RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   FileNotFoundException.class,
                                   NSQuotaExceededException.class,
                                   SafeModeException.class,
                                   SnapshotAccessControlException.class,
                                   UnresolvedPathException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
/**
 * Set the FileEncryptionInfo for an INode.
 */
void setFileEncryptionInfo(String src, FileEncryptionInfo info)
    throws IOException {
  // Make the PB for the xattr
  final HdfsProtos.PerFileEncryptionInfoProto proto =
      PBHelper.convertPerFileEncInfo(info);
  final byte[] protoBytes = proto.toByteArray();
  final XAttr fileEncryptionAttr =
      XAttrHelper.buildXAttr(CRYPTO_XATTR_FILE_ENCRYPTION_INFO, protoBytes);
  final List<XAttr> xAttrs = Lists.newArrayListWithCapacity(1);
  xAttrs.add(fileEncryptionAttr);

  writeLock();
  try {
    FSDirXAttrOp.unprotectedSetXAttrs(this, src, xAttrs,
                                      EnumSet.of(XAttrSetFlag.CREATE));
  } finally {
    writeUnlock();
  }
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
void setXAttr(String src, XAttr xAttr, EnumSet<XAttrSetFlag> flag,
              boolean logRetryCache)
    throws IOException {
  checkOperation(OperationCategory.WRITE);
  HdfsFileStatus auditStat = null;
  writeLock();
  try {
    checkOperation(OperationCategory.WRITE);
    checkNameNodeSafeMode("Cannot set XAttr on " + src);
    auditStat = FSDirXAttrOp.setXAttr(dir, src, xAttr, flag, logRetryCache);
  } catch (AccessControlException e) {
    logAuditEvent(false, "setXAttr", src);
    throw e;
  } finally {
    writeUnlock();
  }
  getEditLog().logSync();
  logAuditEvent(true, "setXAttr", src, null, auditStat);
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
@Override // ClientProtocol
public void setXAttr(String src, XAttr xAttr, EnumSet<XAttrSetFlag> flag)
    throws IOException {
  checkNNStartup();
  CacheEntry cacheEntry = RetryCache.waitForCompletion(retryCache);
  if (cacheEntry != null && cacheEntry.isSuccess()) {
    return; // Return previous response
  }
  boolean success = false;
  try {
    namesystem.setXAttr(src, xAttr, flag, cacheEntry != null);
    success = true;
  } finally {
    RetryCache.setState(cacheEntry, success);
  }
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
/**
 * Set xattr for a file or directory.
 *
 * @param src
 *          - path on which it sets the xattr
 * @param xAttr
 *          - xAttr details to set
 * @param flag
 *          - xAttrs flags
 * @throws IOException
 */
static HdfsFileStatus setXAttr(
    FSDirectory fsd, String src, XAttr xAttr, EnumSet<XAttrSetFlag> flag,
    boolean logRetryCache)
    throws IOException {
  checkXAttrsConfigFlag(fsd);
  checkXAttrSize(fsd, xAttr);
  FSPermissionChecker pc = fsd.getPermissionChecker();
  XAttrPermissionFilter.checkPermissionForApi(
      pc, xAttr, FSDirectory.isReservedRawName(src));
  byte[][] pathComponents = FSDirectory.getPathComponentsForReservedPath(src);
  src = fsd.resolvePath(pc, src, pathComponents);
  List<XAttr> xAttrs = Lists.newArrayListWithCapacity(1);
  xAttrs.add(xAttr);
  INodesInPath iip;
  fsd.writeLock();
  try {
    iip = fsd.getINodesInPath4Write(src);
    checkXAttrChangeAccess(fsd, iip, xAttr, pc);
    unprotectedSetXAttrs(fsd, src, xAttrs, flag);
  } finally {
    fsd.writeUnlock();
  }
  fsd.getEditLog().logSetXAttrs(src, xAttrs, logRetryCache);
  return fsd.getAuditFileInfo(iip);
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
/**
 * Test that xattrs are properly tracked by the standby
 */
@Test(timeout = 60000)
public void testXAttrsTrackedOnStandby() throws Exception {
  fs.create(path).close();
  fs.setXAttr(path, name1, value1, EnumSet.of(XAttrSetFlag.CREATE));
  fs.setXAttr(path, name2, value2, EnumSet.of(XAttrSetFlag.CREATE));

  HATestUtil.waitForStandbyToCatchUp(nn0, nn1);
  List<XAttr> xAttrs = nn1.getRpcServer().getXAttrs("/file", null);
  assertEquals(2, xAttrs.size());
  cluster.shutdownNameNode(0);
  
  // Failover the current standby to active.
  cluster.shutdownNameNode(0);
  cluster.transitionToActive(1);
  
  Map<String, byte[]> xattrs = fs.getXAttrs(path);
  Assert.assertEquals(xattrs.size(), 2);
  Assert.assertArrayEquals(value1, xattrs.get(name1));
  Assert.assertArrayEquals(value2, xattrs.get(name2));
  
  fs.delete(path, true);
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
void setXAttr(String src, XAttr xAttr, EnumSet<XAttrSetFlag> flag,
              boolean logRetryCache)
    throws IOException {
  HdfsFileStatus auditStat = null;
  writeLock();
  try {
    checkOperation(OperationCategory.WRITE);
    checkNameNodeSafeMode("Cannot set XAttr on " + src);
    auditStat = FSDirXAttrOp.setXAttr(dir, src, xAttr, flag, logRetryCache);
  } catch (AccessControlException e) {
    logAuditEvent(false, "setXAttr", src);
    throw e;
  } finally {
    writeUnlock();
  }
  getEditLog().logSync();
  logAuditEvent(true, "setXAttr", src, null, auditStat);
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
/**
 * Set the FileEncryptionInfo for an INode.
 *
 * @param fsd fsdirectory
 * @param src the path of a directory which will be the root of the
 *            encryption zone.
 * @param info file encryption information
 * @throws IOException
 */
static void setFileEncryptionInfo(final FSDirectory fsd, final String src,
    final FileEncryptionInfo info) throws IOException {
  // Make the PB for the xattr
  final HdfsProtos.PerFileEncryptionInfoProto proto =
      PBHelperClient.convertPerFileEncInfo(info);
  final byte[] protoBytes = proto.toByteArray();
  final XAttr fileEncryptionAttr =
      XAttrHelper.buildXAttr(CRYPTO_XATTR_FILE_ENCRYPTION_INFO, protoBytes);
  final List<XAttr> xAttrs = Lists.newArrayListWithCapacity(1);
  xAttrs.add(fileEncryptionAttr);
  fsd.writeLock();
  try {
    FSDirXAttrOp.unprotectedSetXAttrs(fsd, src, xAttrs,
                                      EnumSet.of(XAttrSetFlag.CREATE));
  } finally {
    fsd.writeUnlock();
  }
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
@Override // ClientProtocol
public void setXAttr(String src, XAttr xAttr, EnumSet<XAttrSetFlag> flag)
    throws IOException {
  checkNNStartup();
  namesystem.checkOperation(OperationCategory.WRITE);
  CacheEntry cacheEntry = RetryCache.waitForCompletion(retryCache);
  if (cacheEntry != null && cacheEntry.isSuccess()) {
    return; // Return previous response
  }
  boolean success = false;
  try {
    namesystem.setXAttr(src, xAttr, flag, cacheEntry != null);
    success = true;
  } finally {
    RetryCache.setState(cacheEntry, success);
  }
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
/**
 * Set the FileEncryptionInfo for an INode.
 */
void setFileEncryptionInfo(String src, FileEncryptionInfo info)
    throws IOException {
  // Make the PB for the xattr
  final HdfsProtos.PerFileEncryptionInfoProto proto =
      PBHelper.convertPerFileEncInfo(info);
  final byte[] protoBytes = proto.toByteArray();
  final XAttr fileEncryptionAttr =
      XAttrHelper.buildXAttr(CRYPTO_XATTR_FILE_ENCRYPTION_INFO, protoBytes);
  final List<XAttr> xAttrs = Lists.newArrayListWithCapacity(1);
  xAttrs.add(fileEncryptionAttr);

  writeLock();
  try {
    unprotectedSetXAttrs(src, xAttrs, EnumSet.of(XAttrSetFlag.CREATE));
  } finally {
    writeUnlock();
  }
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
/**
 * Set xattr for a file or directory.
 * 
 * @param src
 *          - path on which it sets the xattr
 * @param xAttr
 *          - xAttr details to set
 * @param flag
 *          - xAttrs flags
 * @throws AccessControlException
 * @throws SafeModeException
 * @throws UnresolvedLinkException
 * @throws IOException
 */
void setXAttr(String src, XAttr xAttr, EnumSet<XAttrSetFlag> flag)
    throws AccessControlException, SafeModeException,
    UnresolvedLinkException, IOException {
  CacheEntry cacheEntry = RetryCache.waitForCompletion(retryCache);
  if (cacheEntry != null && cacheEntry.isSuccess()) {
    return; // Return previous response
  }
  boolean success = false;
  try {
    setXAttrInt(src, xAttr, flag, cacheEntry != null);
    success = true;
  } catch (AccessControlException e) {
    logAuditEvent(false, "setXAttr", src);
    throw e;
  } finally {
    RetryCache.setState(cacheEntry, success);
  }
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
@Override
public void setXAttr(Path path, String name, byte[] value,
    EnumSet<XAttrSetFlag> flag) throws IOException {
  InodeTree.ResolveResult<FileSystem> res =
      fsState.resolve(getUriPath(path), true);
  res.targetFileSystem.setXAttr(res.remainingPath, name, value, flag);
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
@Override
public void setXAttr(Path path, String name, byte[] value,
                     EnumSet<XAttrSetFlag> flag) throws IOException {
  InodeTree.ResolveResult<AbstractFileSystem> res =
      fsState.resolve(getUriPath(path), true);
  res.targetFileSystem.setXAttr(res.remainingPath, name, value, flag);
}
 

import org.apache.hadoop.fs.XAttrSetFlag; //导入依赖的package包/类
public static EnumSet<XAttrSetFlag> convert(int flag) {
  EnumSet<XAttrSetFlag> result =
      EnumSet.noneOf(XAttrSetFlag.class);
  if ((flag & XAttrProtos.XAttrSetFlagProto.XATTR_CREATE_VALUE) ==
      XAttrProtos.XAttrSetFlagProto.XATTR_CREATE_VALUE) {
    result.add(XAttrSetFlag.CREATE);
  }
  if ((flag & XAttrProtos.XAttrSetFlagProto.XATTR_REPLACE_VALUE) ==
      XAttrProtos.XAttrSetFlagProto.XATTR_REPLACE_VALUE) {
    result.add(XAttrSetFlag.REPLACE);
  }
  return result;
}