import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
public void setXAttrs(Map<String, Map<String, byte[]>> xAttrsToSetRaw,
    EnumSet<XAttrSetFlag> flag) throws IOException {
  checkOpen();

  try  {
    Map<String, List<XAttr>> xAttrsToSet = new HashMap<>();
    for (String src : xAttrsToSetRaw.keySet())
    {
      List<XAttr> list = new ArrayList<>();
      Map<String, byte[]> rawList = xAttrsToSetRaw.get(src);
      for (String attrName : rawList.keySet())
        list.add(XAttrHelper.buildXAttr(attrName, rawList.get(attrName)));
      xAttrsToSet.put(src, list);
    }
    namenode.setXAttrs(xAttrsToSet, flag);
  } catch (RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
        FileNotFoundException.class,
        NSQuotaExceededException.class,
        SafeModeException.class,
        SnapshotAccessControlException.class,
        UnresolvedPathException.class);
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Creates a symbolic link.
 * 
 * @see ClientProtocol#createSymlink(String, String,FsPermission, boolean) 
 */
public void createSymlink(String target, String link, boolean createParent)
    throws IOException {
  TraceScope scope = getPathTraceScope("createSymlink", target);
  try {
    FsPermission dirPerm = 
        FsPermission.getDefault().applyUMask(dfsClientConf.uMask); 
    namenode.createSymlink(target, link, dirPerm, createParent);
  } catch (RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   FileAlreadyExistsException.class, 
                                   FileNotFoundException.class,
                                   ParentNotDirectoryException.class,
                                   NSQuotaExceededException.class, 
                                   DSQuotaExceededException.class,
                                   UnresolvedPathException.class,
                                   SnapshotAccessControlException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/** Method to get stream returned by append call */
private DFSOutputStream callAppend(String src, int buffersize,
    EnumSet<CreateFlag> flag, Progressable progress, String[] favoredNodes)
    throws IOException {
  CreateFlag.validateForAppend(flag);
  try {
    LastBlockWithStatus blkWithStatus = namenode.append(src, clientName,
        new EnumSetWritable<>(flag, CreateFlag.class));
    return DFSOutputStream.newStreamForAppend(this, src, flag, buffersize,
        progress, blkWithStatus.getLastBlock(),
        blkWithStatus.getFileStatus(), dfsClientConf.createChecksum(),
        favoredNodes);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   FileNotFoundException.class,
                                   SafeModeException.class,
                                   DSQuotaExceededException.class,
                                   UnsupportedOperationException.class,
                                   UnresolvedPathException.class,
                                   SnapshotAccessControlException.class);
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Set replication for an existing file.
 * @param src file name
 * @param replication replication to set the file to
 * 
 * @see ClientProtocol#setReplication(String, short)
 */
public boolean setReplication(String src, short replication)
    throws IOException {
  TraceScope scope = getPathTraceScope("setReplication", src);
  try {
    return namenode.setReplication(src, replication);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   FileNotFoundException.class,
                                   SafeModeException.class,
                                   DSQuotaExceededException.class,
                                   UnresolvedPathException.class,
                                   SnapshotAccessControlException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Set storage policy for an existing file/directory
 * @param src file/directory name
 * @param policyName name of the storage policy
 */
public void setStoragePolicy(String src, String policyName)
    throws IOException {
  TraceScope scope = getPathTraceScope("setStoragePolicy", src);
  try {
    namenode.setStoragePolicy(src, policyName);
  } catch (RemoteException e) {
    throw e.unwrapRemoteException(AccessControlException.class,
                                  FileNotFoundException.class,
                                  SafeModeException.class,
                                  NSQuotaExceededException.class,
                                  UnresolvedPathException.class,
                                  SnapshotAccessControlException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Rename file or directory.
 * @see ClientProtocol#rename(String, String)
 * @deprecated Use {@link #rename(String, String, Options.Rename...)} instead.
 */
@Deprecated
public boolean rename(String src, String dst) throws IOException {
  checkOpen();
  TraceScope scope = getSrcDstTraceScope("rename", src, dst);
  try {
    return namenode.rename(src, dst);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   NSQuotaExceededException.class,
                                   DSQuotaExceededException.class,
                                   UnresolvedPathException.class,
                                   SnapshotAccessControlException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * delete file or directory.
 * delete contents of the directory if non empty and recursive 
 * set to true
 *
 * @see ClientProtocol#delete(String, boolean)
 */
public boolean delete(String src, boolean recursive) throws IOException {
  checkOpen();
  TraceScope scope = getPathTraceScope("delete", src);
  try {
    return namenode.delete(src, recursive);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   FileNotFoundException.class,
                                   SafeModeException.class,
                                   UnresolvedPathException.class,
                                   SnapshotAccessControlException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Set permissions to a file or directory.
 * @param src path name.
 * @param permission permission to set to
 * 
 * @see ClientProtocol#setPermission(String, FsPermission)
 */
public void setPermission(String src, FsPermission permission)
    throws IOException {
  checkOpen();
  TraceScope scope = getPathTraceScope("setPermission", src);
  try {
    namenode.setPermission(src, permission);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   FileNotFoundException.class,
                                   SafeModeException.class,
                                   UnresolvedPathException.class,
                                   SnapshotAccessControlException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Set file or directory owner.
 * @param src path name.
 * @param username user id.
 * @param groupname user group.
 * 
 * @see ClientProtocol#setOwner(String, String, String)
 */
public void setOwner(String src, String username, String groupname)
    throws IOException {
  checkOpen();
  TraceScope scope = getPathTraceScope("setOwner", src);
  try {
    namenode.setOwner(src, username, groupname);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   FileNotFoundException.class,
                                   SafeModeException.class,
                                   UnresolvedPathException.class,
                                   SnapshotAccessControlException.class);                                   
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
public void modifyAclEntries(String src, List<AclEntry> aclSpec)
    throws IOException {
  checkOpen();
  TraceScope scope = getPathTraceScope("modifyAclEntries", src);
  try {
    namenode.modifyAclEntries(src, aclSpec);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   AclException.class,
                                   FileNotFoundException.class,
                                   NSQuotaExceededException.class,
                                   SafeModeException.class,
                                   SnapshotAccessControlException.class,
                                   UnresolvedPathException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
public void removeAclEntries(String src, List<AclEntry> aclSpec)
    throws IOException {
  checkOpen();
  TraceScope scope = Trace.startSpan("removeAclEntries", traceSampler);
  try {
    namenode.removeAclEntries(src, aclSpec);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   AclException.class,
                                   FileNotFoundException.class,
                                   NSQuotaExceededException.class,
                                   SafeModeException.class,
                                   SnapshotAccessControlException.class,
                                   UnresolvedPathException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
public void removeDefaultAcl(String src) throws IOException {
  checkOpen();
  TraceScope scope = Trace.startSpan("removeDefaultAcl", traceSampler);
  try {
    namenode.removeDefaultAcl(src);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   AclException.class,
                                   FileNotFoundException.class,
                                   NSQuotaExceededException.class,
                                   SafeModeException.class,
                                   SnapshotAccessControlException.class,
                                   UnresolvedPathException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
public void removeAcl(String src) throws IOException {
  checkOpen();
  TraceScope scope = Trace.startSpan("removeAcl", traceSampler);
  try {
    namenode.removeAcl(src);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   AclException.class,
                                   FileNotFoundException.class,
                                   NSQuotaExceededException.class,
                                   SafeModeException.class,
                                   SnapshotAccessControlException.class,
                                   UnresolvedPathException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
public void setAcl(String src, List<AclEntry> aclSpec) throws IOException {
  checkOpen();
  TraceScope scope = Trace.startSpan("setAcl", traceSampler);
  try {
    namenode.setAcl(src, aclSpec);
  } catch(RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
                                   AclException.class,
                                   FileNotFoundException.class,
                                   NSQuotaExceededException.class,
                                   SafeModeException.class,
                                   SnapshotAccessControlException.class,
                                   UnresolvedPathException.class);
  } finally {
    scope.close();
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的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.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
public void removeXAttr(String src, String name) throws IOException {
  checkOpen();
  TraceScope scope = getPathTraceScope("removeXAttr", src);
  try {
    namenode.removeXAttr(src, XAttrHelper.buildXAttr(name));
  } 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.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
static void unprotectedSetOwner(
    FSDirectory fsd, String src, String username, String groupname)
    throws FileNotFoundException, UnresolvedLinkException,
    QuotaExceededException, SnapshotAccessControlException {
  assert fsd.hasWriteLock();
  final INodesInPath inodesInPath = fsd.getINodesInPath4Write(src, true);
  INode inode = inodesInPath.getLastINode();
  if (inode == null) {
    throw new FileNotFoundException("File does not exist: " + src);
  }
  if (username != null) {
    inode = inode.setUser(username, inodesInPath.getLatestSnapshotId());
  }
  if (groupname != null) {
    inode.setGroup(groupname, inodesInPath.getLatestSnapshotId());
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Creates a symbolic link.
 *
 * @see ClientProtocol#createSymlink(String, String,FsPermission, boolean)
 */
public void createSymlink(String target, String link, boolean createParent)
    throws IOException {
  checkOpen();
  try (TraceScope ignored = newPathTraceScope("createSymlink", target)) {
    final FsPermission dirPerm = applyUMask(null);
    namenode.createSymlink(target, link, dirPerm, createParent);
  } catch (RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
        FileAlreadyExistsException.class,
        FileNotFoundException.class,
        ParentNotDirectoryException.class,
        NSQuotaExceededException.class,
        DSQuotaExceededException.class,
        QuotaByStorageTypeExceededException.class,
        UnresolvedPathException.class,
        SnapshotAccessControlException.class);
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Set replication for an existing file.
 * @param src file name
 * @param replication replication to set the file to
 *
 * @see ClientProtocol#setReplication(String, short)
 */
public boolean setReplication(String src, short replication)
    throws IOException {
  checkOpen();
  try (TraceScope ignored = newPathTraceScope("setReplication", src)) {
    return namenode.setReplication(src, replication);
  } catch (RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
        FileNotFoundException.class,
        SafeModeException.class,
        DSQuotaExceededException.class,
        QuotaByStorageTypeExceededException.class,
        UnresolvedPathException.class,
        SnapshotAccessControlException.class);
  }
}
 

import org.apache.hadoop.hdfs.protocol.SnapshotAccessControlException; //导入依赖的package包/类
/**
 * Same {{@link #mkdirs(String, FsPermission, boolean)} except
 * that the permissions has already been masked against umask.
 */
public boolean primitiveMkdir(String src, FsPermission absPermission,
    boolean createParent) throws IOException {
  checkOpen();
  if (absPermission == null) {
    absPermission = applyUMask(null);
  }

  LOG.debug("{}: masked={}", src, absPermission);
  try (TraceScope ignored = tracer.newScope("mkdir")) {
    return namenode.mkdirs(src, absPermission, createParent);
  } catch (RemoteException re) {
    throw re.unwrapRemoteException(AccessControlException.class,
        InvalidPathException.class,
        FileAlreadyExistsException.class,
        FileNotFoundException.class,
        ParentNotDirectoryException.class,
        SafeModeException.class,
        NSQuotaExceededException.class,
        DSQuotaExceededException.class,
        QuotaByStorageTypeExceededException.class,
        UnresolvedPathException.class,
        SnapshotAccessControlException.class);
  }
}