Hadoop-0.20.0源代码分析（16）

最新推荐文章于 2020-10-13 16:05:53 发布
最新推荐文章于 2020-10-13 16:05:53 发布
阅读量404 收藏
点赞数
文章标签： 代码分析 permissions components string null path

这里对与org.apache.hadoop.hdfs.server.namenode.FSDirectory类相关的类进行阅读分析。

  • INodeDirectoryWithQuota类

该类org.apache.hadoop.hdfs.server.namenode.INodeDirectoryWithQuota的继承层次关系如下所示：

[java] view plain copy print ?
  1. ◦org.apache.hadoop.hdfs.server.namenode.INode(implements java.lang.Comparable<byte[]>)  
  2.      ◦org.apache.hadoop.hdfs.server.namenode.INodeDirectory  
  3.           ◦org.apache.hadoop.hdfs.server.namenode.INodeDirectoryWithQuota  

1、INode抽象类

该类是一个保存在内存中的file/block层次结构，一个基本的INode包含了文件和目录inode的通用域（Field） 。下面看INode类定义的属性：

[java] view plain copy print ?
  1. protected byte[] name; // 名称   
  2. protected INodeDirectory parent; // 所在目录   
  3. protected long modificationTime; // 修改时间   
  4. protected long accessTime; // 访问时间   
  5. private long permission; // 权限，只能调用updatePermissionStatus方法设置权限  

INode类提供的构造方法如下所示：

[java] view plain copy print ?
  1. protected INode() { // 受保护构造方法，子类可以继承（初始化INode的属性值）   
  2.   name = null;  
  3.   parent = null;  
  4.   modificationTime = 0;  
  5.   accessTime = 0;  
  6. }  
  7.   
  8. INode(PermissionStatus permissions, long mTime, long atime) { // 根据指定权限创建INode   
  9.   this.name = null;  
  10.   this.parent = null;  
  11.   this.modificationTime = mTime;  
  12.   setAccessTime(atime);  
  13.   setPermissionStatus(permissions); // 设置权限：包括用户名、组、FsPermission信息   
  14. }  
  15.   
  16. protected INode(String name, PermissionStatus permissions) { // 受保护构造方法   
  17.   this(permissions, 0L, 0L);  
  18.   setLocalName(name);  
  19. }  
  20.   
  21. /**  
  22.  * 通过拷贝构造INode实例 
  23.  */  
  24. INode(INode other) {  
  25.   setLocalName(other.getLocalName());  
  26.   this.parent = other.getParent();  
  27.   setPermissionStatus(other.getPermissionStatus());  
  28.   setModificationTime(other.getModificationTime());  
  29.   setAccessTime(other.getAccessTime());  
  30. }  
 

INode类主要就是针对一个INode的名称、所在目录、修改时间、访问时间、权限这些属性来实现操作的，该类中的方法无非实现对这些属性的操作。另外还包括删除该INode，其它几个抽象方法，如下所示：

[java] view plain copy print ?
  1. /** 
  2.  * 检查该INode是否是一个目录 
  3.  */  
  4. public abstract boolean isDirectory();  
  5.   
  6. /** 
  7.  * 收集该INode的所有块（包括该INode的孩子结点），并清除全部对该INode的引用 
  8.  */  
  9. abstract int collectSubtreeBlocksAndClear(List<Block> v);  
  10.   
  11. /** 
  12.  * 计算摘要信息，返回数组包含如下内容： 
  13.  * 0: 内容摘要长度, 1: 文件数量, 2: 目录数量 3: 磁盘空间 
  14.  */  
  15. abstract long[] computeContentSummary(long[] summary);  
  16.   
  17. /** 
  18.  * 获取以该INode为根的磁盘空间与命名空间统计信息 
  19.  * 其中，DirCounts包含nsCount (namespace consumed)和dsCount (diskspace consumed)两个计数器变量 
  20.  */  
  21. abstract DirCounts spaceConsumedInTree(DirCounts counts);  

2、INodeDirectory类

INodeDirectory类是一个目录INode，因此该类内部定义了一个INode列表。该类定义的属性如下：

[java] view plain copy print ?
  1. protected static final int DEFAULT_FILES_PER_DIRECTORY = 5; // 一个目录INode中默认可以存储5个文件   
  2. private List<INode> children; // 以该目录INode为根的INode实例列表  

可以想象得到，作为一个目录，应该提供从目录中检索得到指定的INode的操作，还有就是对引用该INode的INode进行的一些基本操作。这里就不过多阐述了，可以阅读该类的源代码。

3、INodeDirectoryWithQuota类

INodeDirectoryWithQuota类继承自INodeDirectory类，INodeDirectoryWithQuota类表示具有配额限制的目录INode实现类。我们通过该类中定义的一些与配额有关的属性就能了解到这样一种目录INode有什么样的特点：

[java] view plain copy print ?
  1. private long nsQuota; // 命名空间配额限制   
  2. private long nsCount; // 命名空间大小   
  3. private long dsQuota; // 磁盘空间配额限制   
  4. private long diskspace; // 磁盘空间大小  

  • INodeFileUnderConstruction类

该类的继承层次关系如下所示：

[java] view plain copy print ?
  1. ◦org.apache.hadoop.hdfs.server.namenode.INode(implements java.lang.Comparable<byte[]>)  
  2.      ◦org.apache.hadoop.hdfs.server.namenode.INodeFile  
  3.           ◦org.apache.hadoop.hdfs.server.namenode.INodeFileUnderConstruction  

其中，INode类前面已经介绍了，它是一个目录或者文件的INode的抽象。

1、INodeFile类

该类表示一个文件INode，正好与目录INode相对应。因为我们已经阅读分析过目录INode的实现，对该文件INode的实现就比较简单了。看该类的属性：

[java] view plain copy print ?
  1. static final FsPermission UMASK = FsPermission.createImmutable((short)0111); // 文件INode默认权限   
  2.   
  3. protected BlockInfo blocks[] = null; // 块的元数据信息实体的数组   
  4. protected short blockReplication; // 块副本数   
  5. protected long preferredBlockSize; // 块大小  

该类定义了如下几个基本的操作： 

[java] view plain copy print ?
  1. /** 
  2.  * 将块加入到列表blocks中 
  3.  */  
  4. void addBlock(BlockInfo newblock);  
  5.   
  6. /** 
  7.  * 为该文件设置块副本数  
  8.  */  
  9. void setReplication(short replication);  
  10.   
  11. /** 
  12.  * 根据索引位置和块（属于该文件）设置该文件中该块 
  13.  */  
  14. void setBlock(int idx, BlockInfo blk);  

对应的set方法，也存在get实现。

可见，一个INodeFile类实例是不持有任何客户端或者Datanode信息的，就是一个基本的实在的文件。因为在HDFS集群中需要执行计算任务，这要涉及到块的复制等操作，而某些块需要由Namenode调度分派给指定的进程去执行，这就需要一种实体类，既能够包含INodeFile的基本信息，又能够包含与在该INodeFile上执行操作的进程，所以，Hadoop实现了一个INodeFileUnderConstruction类，并在INodeFile类中实现了由INodeFile到INodeFileUnderConstruction的转换，如下所示：

[java] view plain copy print ?
  1. INodeFileUnderConstruction toINodeFileUnderConstruction(String clientName, String clientMachine, DatanodeDescriptor clientNode) throws IOException {  
  2.   if (isUnderConstruction()) { // 如果该INodeFile已经被创建   
  3.     return (INodeFileUnderConstruction)this; // 转换为INodeFileUnderConstruction实例   
  4.   }  
  5.   // 如果该INodeFile没有创建，则直接构造一个INodeFileUnderConstruction实例   
  6.   return new INodeFileUnderConstruction(name,  
  7.       blockReplication, modificationTime, preferredBlockSize,  
  8.       blocks, getPermissionStatus(),  
  9.       clientName, clientMachine, clientNode);  
  10. }  

2、INodeFileUnderConstruction类

该类所含有的信息包括与执行计算任务相关的一些属性，如下所示：

[java] view plain copy print ?
  1. final String clientName;         // 租约（lease）持有者   
  2. private final String clientMachine; // 客户端主机   
  3. private final DatanodeDescriptor clientNode; // 如果客户端同时也是HDFS集群中的Datanode   
  4.   
  5. private int primaryNodeIndex = -1; // 客户端结点激活租约（lease）   
  6. private DatanodeDescriptor[] targets = null;   // 文件最后一个块的存储位置信息   
  7. private long lastRecoveryTime = 0;  

通过上面属性信息可以知道，一个INodeFileUnderConstruction文件具有持有操作该文件的进程（客户端）的一些信息，如果客户端进程同时也是HDFS集群中Datanode，它就能够根据租约的有效性来执行与该文件相关的操作，例如复制等。

下面介绍个主要方法：

1）assignPrimaryDatanode方法

INodeFileUnderConstruction类中实现的assignPrimaryDatanode方法，能够将该INodeFileUnderConstruction文件分配给指定的客户端进程，也就是执行租约恢复的操作，并通过setLastRecoveryTime更新最后租约恢复时间lastRecoveryTime。下面是assignPrimaryDatanode方法的实现：

[java] view plain copy print ?
  1. /** 
  2.  * 为该文件初始化租约的恢复的处理（存储选择的主Datanode所激活的块列表） 
  3.  */  
  4. void assignPrimaryDatanode() {  
  5.   // 指派第一个活跃的为主Datanode结点   
  6.   if (targets.length == 0) {  
  7.     NameNode.stateChangeLog.warn("BLOCK*"  + " INodeFileUnderConstruction.initLeaseRecovery:"  
  8.  " No blocks found, lease removed.");  
  9.   }  
  10.   
  11.   int previous = primaryNodeIndex;  
  12.   // 从索引previous开始查找到一个活跃的Datanode进程   
  13.   for(int i = 1; i <= targets.length; i++) {  
  14.     int j = (previous + i)%targets.length;  
  15.     if (targets[j].isAlive) { // 保证第j个Datanode处于活跃状态   
  16.       DatanodeDescriptor primary = targets[primaryNodeIndex = j];   
  17.       primary.addBlockToBeRecovered(blocks[blocks.length - 1], targets); // 存储被主Datanode激活的块，实际存储到该Datanode的块队列中   
  18.       NameNode.stateChangeLog.info("BLOCK* " + blocks[blocks.length - 1] + " recovery started, primary=" + primary);  
  19.       return;  
  20.     }  
  21.   }  
  22. }  

2）removeBlock方法

该类的removeBlock方法从该文件的块列表中删除一个块，并且只能删除列表中的最后一个块。实现如下所示： 

[java] view plain copy print ?
  1. void removeBlock(Block oldblock) throws IOException {  
  2.   if (blocks == null) {  
  3.     throw new IOException("Trying to delete non-existant block " + oldblock);  
  4.   }  
  5.   int size_1 = blocks.length - 1;  
  6.   if (!blocks[size_1].equals(oldblock)) {  
  7.     throw new IOException("Trying to delete non-last block " + oldblock);  
  8.   }  
  9.   
  10.   BlockInfo[] newlist = new BlockInfo[size_1]; // 创建一个新的块列表（比原来的块列表小1）   
  11.   System.arraycopy(blocks, 0, newlist, 0, size_1); // 将原来的块列表中除去最后一个块以外的全部块，拷贝到新的块列表中   
  12.   blocks = newlist; // 修改当前文件的块列表   
  13.   targets = null; // 因为最后一个块删除了，该块对应的存储位置信息也不存在了   
  14. }  

3）convertToInodeFile方法

该方法将一个INodeFileUnderConstruction文件转化为INodeFile文件，如下所示：

[java] view plain copy print ?
  1. INodeFile convertToInodeFile() {  
  2.   INodeFile obj = new INodeFile(getPermissionStatus(),  
  3.                                 getBlocks(),  
  4.                                 getReplication(),  
  5.                                 getModificationTime(),  
  6.                                 getModificationTime(),  
  7.                                 getPreferredBlockSize());  
  8.   return obj;      
  9. }  

  • FSDirectory类

该类org.apache.hadoop.hdfs.server.namenode.FSDirectory用来存储文件系统目录的状态。它处理向磁盘中写入或加载数据，并且对目录中的数据发生的改变记录到日志中。它保存了一个最新的filename->blockset的映射表，并且将它写入到磁盘中。

该类定义的属性如下所示：

[java] view plain copy print ?
  1. final FSNamesystem namesystem; // 文件系统命名空间系统实例   
  2. final INodeDirectoryWithQuota rootDir; // 具有配额限制的目录INode，这里即是根目录   
  3. FSImage fsImage;  // FSImage映像   
  4. private boolean ready = false; // 该目录是否准备好处理writing/loading到磁盘   
  5. private MetricsRecord directoryMetrics = null; // 目录元数据记录实体  

该类构造方法如下所示：

[java] view plain copy print ?
  1. FSDirectory(FSNamesystem ns, Configuration conf) {  
  2.   this(new FSImage(), ns, conf);  
  3.   fsImage.setCheckpointDirectories(FSImage.getCheckpointDirs(conf, null), FSImage.getCheckpointEditsDirs(conf, null));  
  4. }  
  5.   
  6. FSDirectory(FSImage fsImage, FSNamesystem ns, Configuration conf) {  
  7.   rootDir = new INodeDirectoryWithQuota(INodeDirectory.ROOT_NAME, ns.createFsOwnerPermissions(new FsPermission((short)0755)), Integer.MAX_VALUE, -1); // 目录的权限设为755（drwxrw-rw-）   
  8.   this.fsImage = fsImage; // 后面会详细分析FSImage映像类的   
  9.   namesystem = ns;  
  10.   initialize(conf); // 调用，根据配置类实例conf初始化directoryMetrics   
  11. }  

通过上面的FSDirectory的构造可以看出，通过FSNamesystem ns访问一个已经存在的DFS的命名空间系统目录，为FSDirectory的根目录rootDir设置访问权限。

下面介绍FSDirectory类的方法，选择几个重要的方法详细分析：

1、加载FSImage映像

方法loadFSImage实现如下所示： 

 

[java] view plain copy print ?
  1. void loadFSImage(Collection<File> dataDirs, Collection<File> editsDirs, StartupOption startOpt) throws IOException {  
  2.    // 根据Hadoop servers启动选项进行操作   
  3.   if (startOpt == StartupOption.FORMAT) { // 如果启动选项类型为FORMAT（格式化），在启动之前需要进行格式化   
  4.     fsImage.setStorageDirectories(dataDirs, editsDirs); // 设置FSImage映像文件文件的存储目录   
  5.     fsImage.format(); // 对FSImage执行格式化操作   
  6.     startOpt = StartupOption.REGULAR; // 动态修改启动选项REGULAR（正常启动）   
  7.   }  
  8.   try {  
  9.     if (fsImage.recoverTransitionRead(dataDirs, editsDirs, startOpt)) { // 根据启动选项及其对应存储目录，分析存储目录，必要的话从先前的事务恢复过来   
  10.       fsImage.saveFSImage(); // 保存FSImage映像文件内容，并创建一个空的edits文件   
  11.     }  
  12.     FSEditLog editLog = fsImage.getEditLog(); // 获取到存FSImage映像对应的EditLog文件   
  13.     assert editLog != null : "editLog must be initialized";  
  14.     if (!editLog.isOpen())  
  15.       editLog.open(); // 打开EditLog文件   
  16.     fsImage.setCheckpointDirectories(null, null); // 设置检查点存储目录   
  17.   } catch(IOException e) {  
  18.     fsImage.close();  
  19.     throw e;  
  20.   }  
  21.   synchronized (this) {  
  22.     this.ready = true; // 设置当前FSDirectory状态   
  23.     this.notifyAll(); // 通知阻塞在该FSDirectory对象上的全部其它线程   
  24.   }  
  25. }  

通过该方法，我们可以看到加载一个FSImage映像的过程：首先需要对内存中的FSImage对象进行格式化；然后从将指定存储目录中的EditLog日志文件作用到格式化完成的FSImage内存映像上；最后需要再创建一个空的EditLog日志准备记录对命名空间进行修改的操作，以备检查点进程根据需要将EditLog内容作用到FSImage映像上，保持FSImage总是最新的，保证EditLog与FSImage同步。

2、更新INode文件计数

实现的方法为updateCount，如下所示：

[java] view plain copy print ?
  1. /**  
  2.  * 批量更新：更新具有配额限制的每一个INode的计数 
  3.  *  
  4.  * @param inodes 某个Path下的INode数组 
  5.  * @param numOfINodes 需要更新的INode的数量（从数组inodes的索引0开始计数） 
  6.  * @param nsDelta 文件系统命名空间大小的改变量 
  7.  * @param dsDelta 磁盘空间大小的改变量 
  8.  */  
  9. private void updateCount(INode[] inodes, int numOfINodes, long nsDelta, long dsDelta) throws QuotaExceededException {  
  10.   if (!ready) {   
  11.     return;  
  12.   }  
  13.   if (numOfINodes>inodes.length) { // 检查numOfINodes，当大于inodes数组大小时，设置为inodes数组大小   
  14.     numOfINodes = inodes.length;  
  15.   }  
  16.   // check existing components in the path     
  17.   int i=0;  
  18.   try {  
  19.     for(; i < numOfINodes; i++) {  
  20.       if (inodes[i].isQuotaSet()) { // 如果是一个具有配额限制的目录INode   
  21.         INodeDirectoryWithQuota node =(INodeDirectoryWithQuota)inodes[i]; // 转换，得到INodeDirectoryWithQuota实例   
  22.         node.updateNumItemsInTree(nsDelta, dsDelta); // 更新node目录树的大小   
  23.       }  
  24.     }  
  25.   } catch (QuotaExceededException e) {  
  26.     e.setPathName(getFullPathName(inodes, i));  
  27.     // 发生异常，执行回滚上述更新操作   
  28.     for( ; i-- > 0; ) {  
  29.       try {  
  30.         if (inodes[i].isQuotaSet()) {   
  31.           INodeDirectoryWithQuota node =(INodeDirectoryWithQuota)inodes[i];   
  32.           node.updateNumItemsInTree(-nsDelta, -dsDelta);  
  33.         }  
  34.       } catch (IOException ingored) {  
  35.       }  
  36.     }  
  37.     throw e;  
  38.   }  
  39. }  

文件系统中的INode（目录或文件）可能因为在执行计算任务过程中，某个INode（树）的内容发生变化，为保证HDFS中文件管理的一致性，在必要的时候需要更新INode的统计数据。

3、向该目录中添加一个孩子INode

实现方法为addChild，如下所示：

[java] view plain copy print ?
  1. private <T extends INode> T addChild(INode[] pathComponents, int pos, T child, long childDiskspace, boolean inheritPermission) throws QuotaExceededException {  
  2.   INode.DirCounts counts = new INode.DirCounts();  
  3.   child.spaceConsumedInTree(counts); // 更新counts对象（该对象包含child在目录树中INode名字的数量与占用磁盘空间）   
  4.   if (childDiskspace < 0) {  
  5.     childDiskspace = counts.getDsCount(); // 获取child的磁盘空间大小   
  6.   }  
  7.   updateCount(pathComponents, pos, counts.getNsCount(), childDiskspace); // 更新pathComponents数组从0到pos-1位置的每一个INode的统计计数   
  8.   T addedNode = ((INodeDirectory)pathComponents[pos-1]).addChild(child, inheritPermission); // 将child添加到((INodeDirectory)pathComponents[pos-1])目录中，并返回child结点   
  9.   if (addedNode == null) { // 如果((INodeDirectory)pathComponents[pos-1])中已经存在child结点   
  10.     updateCount(pathComponents, pos, -counts.getNsCount(), -childDiskspace); // 回滚上述更新操作   
  11.   }  
  12.   return addedNode; // 返回添加到该目录中的INode   
  13. }  

4、向namespace中添加一个INode

实现的方法为addNode，如下所示：

[java] view plain copy print ?
  1. /**  
  2.  * 将node添加到namespace中，node的完整路径为src，如果该node磁盘空间childDiskspace未知则应该为-1 
  3.  */  
  4. private <T extends INode> T addNode(String src, T child, long childDiskspace, boolean inheritPermission) throws QuotaExceededException {  
  5.   byte[][] components = INode.getPathComponents(src); // 将路径src转换为UTF-8编码的字节数组   
  6.   child.setLocalName(components[components.length-1]); // 为child设置本地文件名称   
  7.   INode[] inodes = new INode[components.length]; // 分配一个components.length大小的INode[]   
  8.   synchronized (rootDir) {  
  9.     rootDir.getExistingPathINodes(components, inodes);  
  10.     return addChild(inodes, inodes.length-1, child, childDiskspace, inheritPermission);  
  11.   }  
  12. }  

上面调用了INodeDirectory类的getExistingPathINodes方法，这里说明一下该方法。

例如，给定一个路径/c1/c2/c3，其中只有/c1/c2是存在的，而/c3不存在，则得到这样一个字节数组["","c1","c2","c3"]。

如果想要执行调用getExistingPathINodes(["","c1","c2"], [?])，则应该使用[c2]填充占位数组；

如果想要执行调用getExistingPathINodes(["","c1","c2","c3"], [?])，则应该使用[null]填充占位数组；

如果想要执行调用getExistingPathINodes(["","c1","c2"], [?,?])，则应该使用[c1,c2]填充占位数组；

如果想要执行调用getExistingPathINodes(["","c1","c2","c3"], [?,?])，则应该使用[c2,null]填充占位数组；

如果想要执行调用getExistingPathINodes(["","c1","c2"], [?,?,?,?])，则应该使用[rootINode,c1,c2,null]填充占位数组；

如果想要执行调用getExistingPathINodes(["","c1","c2","c3"], [?,?,?,?])，则应该使用[rootINode,c1,c2,null]填充占位数组。

对应于上面方法中，对getExistingPathINodes方法的调用，指定一个完整路径components（例如上面的src转化后得到的components数组），执行调用后，会根据上述举例中的规则来对inodes数组进行填充。得到一个inodes数组以后，就可以调用addChild方法向该目录FSDirectory中添加一个child。

5、向文件系统中添加一个文件

实现的方法为addFile，如下所示：

[java] view plain copy print ?
  1. INodeFileUnderConstruction addFile(   
  2.               String path,  
  3.               PermissionStatus permissions,  
  4.               short replication,  
  5.               long preferredBlockSize,  
  6.               String clientName,  
  7.               String clientMachine,  
  8.               DatanodeDescriptor clientNode,  
  9.               long generationStamp)  throws IOException {  
  10.   waitForReady(); // 等待该目录已经准备好，能够被使用   
  11.   long modTime = FSNamesystem.now(); // 取当前时间   
  12.   if (!mkdirs(new Path(path).getParent().toString(), permissions, true, modTime)) { // 创建path的父目录   
  13.     return null;  
  14.   }  
  15.   INodeFileUnderConstruction newNode = new INodeFileUnderConstruction(  
  16.                                permissions,replication,  
  17.                                preferredBlockSize, modTime, clientName,   
  18.                                clientMachine, clientNode); // 创建一个新的INode文件   
  19.   synchronized (rootDir) {  
  20.     newNode = addNode(path, newNode, -1, false); // 将newNode加入到namespace中去   
  21.   }  
  22.   if (newNode == null) { // 添加失败   
  23.     NameNode.stateChangeLog.info("DIR* FSDirectory.addFile: " +"failed to add "+path  
  24. " to the file system");  
  25.     return null;  
  26.   }  
  27.   fsImage.getEditLog().logOpenFile(path, newNode); // 将namespace中新添加INode的事务写入到FSImage对应的EditLog日志文件中   
  28.   NameNode.stateChangeLog.debug("DIR* FSDirectory.addFile: "  +path+" is added to the file system");  
  29.   return newNode;  
  30. }  

通过该方法，我们了解到，当向namespace中添加一个文件的时候，需要通过FSImage映像获取到其所对应的EditLog日志文件，将对使namespace发生改变的事务记录下来。只要当对namespace执行的操作生效的时候，才会被记录到EditLog日志文件中，如果失败的话是不会登陆日志的。

6、向指定文件中写入块（Block）

如下所示：

[java] view plain copy print ?
  1. Block addBlock(String path, INode[] inodes, Block block) throws IOException {  
  2.   waitForReady();  
  3.   synchronized (rootDir) {  
  4.     INodeFile fileNode = (INodeFile) inodes[inodes.length-1]; // inodes数组中最后一个INodeFile   
  5.     // 检查配额限制，更新空间用量   
  6.     updateCount(inodes, inodes.length-1, 0, fileNode.getPreferredBlockSize()*fileNode.getReplication());  
  7.       
  8.     // associate the new list of blocks with this file   
  9.     namesystem.blocksMap.addINode(block, fileNode); // 将该块block加入到namesystem所维护的映射表blocksMap中的fileNode文件中去   
  10.     BlockInfo blockInfo = namesystem.blocksMap.getStoredBlock(block); // 获取到namesystem所维护的blocksMap映射表中，block块的信息blockInfo   
  11.     fileNode.addBlock(blockInfo); // 将blockInfo信息添加到fileNode文件中   
  12.   
  13.     NameNode.stateChangeLog.debug("DIR* FSDirectory.addFile: "  
  14.                                   + path + " with " + block  
  15.                                   + " block is added to the in-memory "  
  16.                                   + "file system");  
  17.   }  
  18.   return block;  
  19. }  

可见，每当需要向目录中写入块（Block）的时候，都需要向FSNamesystem的blocksMap映射表中登记，同时通过从FSNamesystem的blocksMap映射表中获取待写入块已经存在的信息，一同写入到该目录中该块所属的文件中去。

7、需要写入EditLog日志文件的操作

这里，对FSDirectory类中实现的，与namespace相关的需要写入到EditLog日志文件的事务进行总结，给出具体的操作说明。

一共涉及到12个操作，执行这些操作的时候，需要登录到EditLog日志中，如下所示：

[java] view plain copy print ?
  1. /** 
  2.  * 将文件添加到文件系统中 
  3.  */  
  4. INodeFileUnderConstruction addFile(  
  5.               String path,   
  6.               PermissionStatus permissions,  
  7.               short replication,  
  8.               long preferredBlockSize,  
  9.               String clientName,  
  10.               String clientMachine,  
  11.               DatanodeDescriptor clientNode,  
  12.               long generationStamp) throws IOException;  
  13.   
  14. /** 
  15.  * 将一个文件对应的块列表持久化到文件系统 
  16.  */  
  17. void persistBlocks(String path, INodeFileUnderConstruction file) IOException；  
  18.   
  19. /** 
  20.  * 关闭文件 
  21.  */  
  22. void closeFile(String path, INodeFile file) throws IOException;  
  23.   
  24. /** 
  25.  * 删除指定文件的某个块 
  26.  */  
  27. boolean removeBlock(String path, INodeFileUnderConstruction fileNode, Block block) throws IOException;  
  28.   
  29. /** 
  30.  * 文件重命名 
  31.  */  
  32. boolean renameTo(String src, String dst) throws QuotaExceededException;  
  33.   
  34. /** 
  35.  * 为指定文件设置副本因子 
  36.  */  
  37. Block[] setReplication(String src, short replication, int[] oldReplication) throws IOException;  
  38.   
  39. /** 
  40.  * 为指定文件设置权限 
  41.  */  
  42. void setPermission(String src, FsPermission permission) throws IOException;  
  43.   
  44. /** 
  45.  * 设置文件属主 
  46.  */  
  47. void setOwner(String src, String username, String groupname) throws IOException;  
  48.   
  49. /** 
  50.  * 删除文件 
  51.  */  
  52. INode delete(String src);  
  53.   
  54. /** 
  55.  * 创建目录 
  56.  */  
  57. boolean mkdirs(String src, PermissionStatus permissions, boolean inheritPermission, long now) throws FileNotFoundException, QuotaExceededException;  
  58.   
  59. /** 
  60.  * 为指定目录设置配额  
  61.  */  
  62. void setQuota(String src, long nsQuota, long dsQuota) throws FileNotFoundException, QuotaExceededException;  
  63.   
  64. /** 
  65.  * 设置一个文件的访问时间 
  66.  */  
  67. void setTimes(String src, INodeFile inode, long mtime, long atime, boolean force) throws IOException;  
 

对于FSDirectory类，我们就分析这么多。通过上面分析，我们知道了FSDirectory类主要是管理对于属于一个FSDirectory类目录实例的文件的基本操作，而一个FSDirectory类是位于文件系统中的，对于指定的文件进行的操作都由FSDirectory类来管理维护，并对特定的事务写入到EditLog日志文件中。

aeh129
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hadoop 2.6.0 FSDirectory源代码分析
houzhizhen的专栏
01-25 746
FSDirectory和FSNamesystem类管理命名空间的状态，FSDirectory 完全是内存的数据结构，它的所有操作都发生在内存中。相反，FSNamesystem把所有的操作都持久化到磁盘上。 /** * Both FSDirectory and FSNamesystem manage the state of the namespace. * FSDirectory is
Hadoop 源代码分析（二三）FSDirectory
weixin_33717117的博客
05-29 103
为什么80%的码农都做不了架构师？>>> ...
Hadoop源码分析_NameNode regular初始化 （FSDirectory详解）
李战磊专栏
10-27 1100
FSNamesystem private void initialize(NameNode nn, Configuration conf) throws IOException对FSDirectory进行了如下调用 this.dir = new FSDirectory(this, conf); StartupOption startOpt = NameNode.getStartupOption
Hadoop学习二十三：Hadoop-Hdfs FSDirectory 源码
zy19982004的专栏
07-03 187
一. FSDirectory 上文Hadoop学习二十二：Hadoop-Hdfs INode源码讲到INode是文件层次结构的反应。那文件层次结构由谁去维护，就是由FSDirectory维护。 我把从客户端发起一个操作到最终完成这一操作所经过的类，依次划分为外层-底层。那FSNamesystem算的上底层的东西，FSDirectory就是更底层的东西。 所有会导致文件层次结构变化的操...
hadoop-0.20.0.tar
09-11
这个“hadoop-0.20.0.tar”文件是Hadoop的一个早期版本，它包含了运行和开发Hadoop应用所需的所有组件。 Hadoop的核心由两个主要部分组成：Hadoop Distributed File System（HDFS）和MapReduce。HDFS是一种高度容错...
hadoop-core-0.20.0免费下载
03-23
在标题中提到的"hadoop-core-0.20.0"是Hadoop早期的一个版本，它包含了运行Hadoop集群所需的基本组件和库文件。这个版本的发布对于Hadoop的发展具有重要意义，因为它引入了许多改进和新特性，使得Hadoop在处理大数据...
hdfs-over-ftp-hadoop-0.20.0.rar_ftp_ftpoverhdfs_hdfs文件传入ftp_java
09-14
压缩包子文件 "hdfs-over-ftp-hadoop-0.20.0" 没有提供具体的文件名，但我们可以假设它包含了源代码、文档、配置文件等，这些内容可能包括： 1. **源代码**：实现了FTP与HDFS交互的Java类和库，可能包括FTP服务器的...
hadoop-1.0源代码（全）
08-03
Hadoop是Apache软件基金会开发的一个开源分布式计算框架，它的出现为大数据处理提供了高效、可靠的解决方案。...通过阅读和分析源代码，我们可以更好地理解大数据处理的底层逻辑，从而提升自己的技能和解决问题的能力。
hadoop-src源代码
05-23
《深入剖析Hadoop-src源代码》 Hadoop作为大数据处理领域的基石，其源代码是学习分布式计算、数据存储和管理的宝贵资源。"hadoop-src"压缩文件包含了Hadoop项目的所有源代码，使得开发者能够直接在Eclipse等Java...
Spark计算Pi运行过程详解---Spark学习笔记4
热门推荐
OopsOutOfMemory盛利的博客
03-31 1万+
上回运行了一个计算Pi的例子 那么Spark究竟是怎么执行的呢？ 我们来看一下脚本 #!/bin/sh export YARN_CONF_DIR=/home/victor/software/hadoop-2.2.0/etc/hadoop SPARK_JAR=./assembly/target/scala-2.9.3/spark-assembly-0.8.1-incubat
hdfs quota物理空间转逻辑空间
王小禾
05-22 721
1.现有quota的设置与使用 1.setQuota客户端到NN的主要流程 2.count -q / -u 查看quota 2.quota在hadoop中的限制作用 2.SpaceQuota改逻辑空间 1.改动 2.测试 put mv setrep du rm 重启后查看 cp 子目录测试 EC测试 进一步测试 4.可能的问题 1.现有quota的设置与使用 1.setQuota客户端到NN的主要流程 s...
Hadoop学习总结之二：HDFS读写过程解析
forfuture1978的专栏
11-10 4706
一、文件的打开 1.1、客户端 HDFS打开一个文件，需要在客户端调用DistributedFileSystem.open(Path f, int bufferSize)，其实现为： public FSDataInputStream open(Path f, int bufferSize) throws IOException {   return new DFSClient.DFSDataInputStream(     
hadoop2.7.3源码解析之hdfs删除文件全流程分析
公众号[大数据技术与应用实战]，分享大数据实战案例
07-30 2888
客户端删除文件 namenode删除文件 从命名空间删除文件 将相应的数据块加到InvalidateBlocks中 ReplicationMonitor监控线程 心跳生成删除命令 datanode删除相应的block并汇报 心跳处理删除命令 异步单独开启线程删除磁盘数据 向namenode汇报删除的块 namenode处理删除block的汇报 总结客户端删除文件先来一段简单的代码,用java的api
Hadoop记录-HDFS配额Quota
weixin_30338481的博客
02-27 314
设置文件数配额 hdfsdfsadmin-setQuota<N><directory>...<directory> 例如：设置目录下的文件总数为1000个hdfs dfsadmin -setQuota 1000 /p/work 清除配额 hdfsdfsadmin-clrQuota<directory>...<direct...
Hadoop3.2.1 【 HDFS 】源码分析 :BlockManager解析 [二]
张伯毅的专栏
10-13 4675
Table of Contents 1. 构造方法 2.常量 3.RedundancyMonitor 3.1.前言 3.2.computeDatanodeWork 3.3.processPendingReconstructions 3.4.rescanPostponedMisreplicatedBlocks BlockManager类保存并且管理了HDFS集群中所有数据块的元数据。 1. 构造方法 FSNamesystem在调用构造方法初始化的时候会构建BlockMa...
Hadoop NameNode启动之载入FSImage(二)
海盗的小菜园
08-22 1165
上一篇分析了启动过程中，载入FSImage之前的一系列校验，这次开始看下FSImage真正的载入部分，在这里可以看到对该文件读操作，通过这些操作可以知道该文件的结构，以及内存中的结构，个人觉得HDFS出于安全、恢复方面的考虑，在启动过程中做了相当的校验，但就单纯读取该文件来说，流程还是比较好理解的，如果熟悉JAVA的文件读写的话，这个函数喽一眼就知道个大概了。有一点需要注意，比如我们在集群中有这样
POI 解析Excel Cannot remove block[ xx ]; out of range[ 0 - xx ] 问题分析
weixin_34380781的博客
10-26 813
2019独角兽企业重金招聘Python工程师标准>>> ...
Hadoop HDFS源码学习笔记（四）
一剪梅
03-13 1663
一、首先根据HDFS的API写一段程序，然后是用Eclipse进行debug 单步跟踪，从而查看源码执行流程： import java.net.URI; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs
hdfs-over-ftp-0.20.0.tar.gz 下载
最新发布
11-12
您可以通过以下链接下载hdfs-over-ftp-0.20.0.tar.gz文件：[链接](https://www.apache.org/dyn/closer.cgi/hadoop/common/hadoop-0.20.0/hadoop-0.20.0.tar.gz) 请点击链接，然后选择一个最近的镜像站点进行下载。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值