一.FSDataset类图
二.FSVolume FSDir物理概念
三.Block
- Block类只代表一个block的标识，看Block类的属性便知；Block类不代表block文件。
- blk_1150083481087817002是block；%hadoop_home%/dfs/data/current/blk_115008348108781700是block文件。
- block包含block blk_1150083481087817002和block元数据 blk_1150083481087817002_1007.meta。本系列博客中没有特别说明时，block只表示block blk_1150083481087817002。
//blk_1150083481087817002
//blk_1150083481087817002_1007.meta
public class Block implements Writable, Comparable<Block> {
//change fileName to id
static long filename2id(String name) {
return Long.parseLong(name.substring("blk_".length()));
}
//change id to fileName
public String getBlockName() {
return "blk_" + String.valueOf(blockId);
}
private long blockId; //block id：1150083481087817002
private long numBytes; //block大小
private long generationStamp; //从1000L开始：1007 当两个块进行比较的时候，当它们的hashcode相同时，便用generationStamp进行比较
public Block() {
this(0, 0, 0);
}
//blockId相同
//generationStamp时间相同两个条件
public boolean equals(Object o) {
if (!(o instanceof Block)) {
return false;
}
final Block that = (Block) o;
return this.blockId == that.blockId
&& GenerationStamp.equalsWithWildcard(this.generationStamp,
that.generationStamp);
}
//根据blockId计算hashcode
public int hashCode() {
return 37 * 17 + (int) (blockId ^ (blockId >>> 32));
}
}
四.BlockAndFile
BlockAndFile类代表了block与block文件的对应关系。
// block与block文件的对应关系
static class BlockAndFile implements Comparable<BlockAndFile> {
final Block block;
// absolute path eg:%hadoop_home%/dfs/data/current/blk_1150083481087817002
final File pathfile;
BlockAndFile(File fullpathname, Block block) {
this.pathfile = fullpathname;
this.block = block;
}
public int compareTo(BlockAndFile o) {
return this.block.compareTo(o.block);
}
}
五.DatanodeBlockInfo
- DatanodeBlockInfo保存了block在文件系统上的信息，包含block存放的卷（FSVolume），文件名和detach状态。
- detach状态：系统在升级时会创建一个snapshot，snapshot的文件和current里的数据块文件和数据块元文件是通过硬链接，指向了相同的内容。当我们需要改变current里的文件时，如果不进行detach操作，那么，修改的内容就会影响snapshot里的文件，这时，我们需要将对应的硬链接解除掉。方法很简单，就是在临时文件夹里，复制文件，然后将临时文件改名成为current里的对应文件，这样的话，current里的文件和snapshot里的文件就detach了。这样的技术，也叫copy-on-write，是一种有效提高系统性能的方法。DatanodeBlockInfo中的detachBlock，能够对Block对应的数据文件和元数据文件进行detach操作。
//Block----->DatanodeBlockInfo class DatanodeBlockInfo { private FSVolume volume; // block所在的FSVolume private File file; // block文件 private boolean detached; // copy-on-write done for block DatanodeBlockInfo(FSVolume vol, File file) { this.volume = vol; this.file = file; detached = false; } /** * 1. Copy specified file into a temporary file. * 2. Then rename the temporary file to the original name. * This will cause any hardlinks to the original file to be removed. * The temporary files are created in the detachDir. * The temporary files will be recovered (especially on Windows) on datanode restart. */ private void detachFile(File file, Block b) throws IOException { ... } } /** * Returns true if this block was copied, otherwise returns false. */ boolean detachBlock(Block block, int numLinks) throws IOException { 。。。 } }
六.FSDir
- FSDir是保存block的文件夹。
- FSDir是一个树状结构，最外层是%hadoop_home%/dfs/data/current。
- 初始化FSDir时，迭代初始化%hadoop_home%/dfs/data/current下的所有children FSDir，构成FSDir树。
- FSDir的重要方法
- addBlock：向此FSDir中添加block，返回这个block对应的block文件。
- getBlockAndFileInfo：获得此FSDir下所有BlockAndFile。
- getVolumeMap：获得此FSDir下所有block到DatanodeBlockInfo的映射关系。
// 保存block的文件夹 class FSDir { File dir; // FSDir会有一个根目录，最外面的当然是/current int numBlocks = 0; // FSDir下的block数量 FSDir children[]; // FSDir下可以继续包含FSDir int lastChildIdx = 0; // 存储上一个数据块的子目录序号 // 初始化时，构建FSDir树 public FSDir(File dir) throws IOException { this.dir = dir; this.children = null; File[] files = FileUtil.listFiles(dir); int numChildren = 0; for (int idx = 0; idx < files.length; idx++) { if (files[idx].isDirectory()) { numChildren++; } else if (Block.isBlockFilename(files[idx])) { numBlocks++; } } if (numChildren > 0) { children = new FSDir[numChildren]; int curdir = 0; for (int idx = 0; idx < files.length; idx++) { if (files[idx].isDirectory()) { // 迭代初始化children FSDir children[curdir] = new FSDir(files[idx]); curdir++; } } } } public File addBlock(Block b, File src) throws IOException { // First try without creating subdirectories File file = addBlock(b, src, false, false); return (file != null) ? file : addBlock(b, src, true, true); } private File addBlock(Block b, File src, boolean createOk, boolean resetIdx) throws IOException { // DataNode节点会首先把文件的数据块存储到存储路径的子目录current/下 if (numBlocks < maxBlocksPerDir) { // src:tmp下 // dest:current下 File dest = new File(dir, b.getBlockName()); // metaData:tmp下 // newmeta:current下 File metaData = getMetaFile(src, b); File newmeta = getMetaFile(dest, b); // tmp下metaData移到current下，tmp下block移到current下 if (!metaData.renameTo(newmeta) || !src.renameTo(dest)) { throw new IOException("could not move files for " + b + " from tmp to " + dest.getAbsolutePath()); } numBlocks += 1; return dest; } // 当子目录current/中已经存储了maxBlocksPerDir个数据块之后 // 就会在目录current/下创建maxBlocksPerDir个子目录，然后从中选择一个子目录，把数据块存储到这个子目录中； // 如果选择的子目录也已经存储了maxBlocksPerDir个数据块，则又在这个子目录下创建maxBlocksPerDir个子目录，从这些子目录中选一个来存储数据块 // 就这样一次递归下去，直到存储路径的剩余存储空间不够存储一个数据块为止。 // maxBlocksPerDir的默认值是64，但也可以通过DataNode的配置文件来设置，它对应的配置选项是dsf.datanode.numblocks。 if (lastChildIdx < 0 && resetIdx) { // reset so that all children will be checked lastChildIdx = random.nextInt(children.length); } if (lastChildIdx >= 0 && children != null) { // Check if any child-tree has room for a block. for (int i = 0; i < children.length; i++) { int idx = (lastChildIdx + i) % children.length; File file = children[idx].addBlock(b, src, false, resetIdx); if (file != null) { lastChildIdx = idx; return file; } } lastChildIdx = -1; } if (!createOk) { return null; } if (children == null || children.length == 0) { children = new FSDir[maxBlocksPerDir]; for (int idx = 0; idx < maxBlocksPerDir; idx++) { children[idx] = new FSDir(new File(dir, DataStorage.BLOCK_SUBDIR_PREFIX + idx)); } } // now pick a child randomly for creating a new set of subdirs. lastChildIdx = random.nextInt(children.length); return children[lastChildIdx].addBlock(b, src, true, false); } // 获得此FSDir下所有BlockAndFile void getBlockAndFileInfo(TreeSet<BlockAndFile> blockSet) { // 迭代children FSDir if (children != null) { for (int i = 0; i < children.length; i++) { children[i].getBlockAndFileInfo(blockSet); } } File blockFiles[] = dir.listFiles(); for (int i = 0; i < blockFiles.length; i++) { if (Block.isBlockFilename(blockFiles[i])) { long genStamp = FSDataset.getGenerationStampFromFile( blockFiles, blockFiles[i]); Block block = new Block(blockFiles[i], blockFiles[i].length(), genStamp); blockSet.add(new BlockAndFile(blockFiles[i] .getAbsoluteFile(), block)); } } } // 建立Block到DatanodeBlockInfo的映射关系 void getVolumeMap(HashMap<Block, DatanodeBlockInfo> volumeMap, FSVolume volume) { // 迭代children FSDir if (children != null) { for (int i = 0; i < children.length; i++) { children[i].getVolumeMap(volumeMap, volume); } } File blockFiles[] = dir.listFiles(); if (blockFiles != null) { for (int i = 0; i < blockFiles.length; i++) { if (Block.isBlockFilename(blockFiles[i])) { long genStamp = FSDataset.getGenerationStampFromFile( blockFiles, blockFiles[i]); volumeMap.put( new Block(blockFiles[i], blockFiles[i].length(), genStamp), new DatanodeBlockInfo(volume, blockFiles[i])); } } } } }
七.FSVolume
- FSVolume对应着DataNode上的一个Storage。一个DataNode可以配置多个Storage，一个DataNode包含多个FSVolume。
- FSVolume的重要方法
- getDfsUsed磁盘使用量 getCapacity磁盘大小 getAvailable磁盘可用量
- addBlock：向FSVolume中添加block，调用FSDir.addBlock完成。
- getVolumeMap：获得此FSVolume下所有block到DatanodeBlockInfo的映射关系，调用FSDir.getVolumeMap完成。
// FSVolume对应一个Storage // 一个DataNode可以配置多个Storage，一个DataNode包含多个FSVolume class FSVolume { private File currentDir; private FSDir dataDir; private File tmpDir; private File blocksBeingWritten; // clients write here private File detachDir; // copy on write for blocks in snapshot private DF usage; private DU dfsUsage; //<property> // <name>dfs.datanode.du.reserved</name> // <value>1024</value> //</property> //每个磁盘写入点能预留1K的空间来 private long reserved; // 初始化一个FSVolume FSVolume(File currentDir, Configuration conf) throws IOException { this.reserved = conf.getLong("dfs.datanode.du.reserved", 0); this.dataDir = new FSDir(currentDir); this.currentDir = currentDir; //根据parent初始化下面各属性，parent is %hadoop_home%/dfs/data File parent = currentDir.getParentFile(); this.detachDir = new File(parent, "detach"); // remove all blocks from "tmp" directory. These were either created // by pre-append clients (0.18.x) or are part of replication // request. // They can be safely removed. this.tmpDir = new File(parent, "tmp"); if (tmpDir.exists()) { FileUtil.fullyDelete(tmpDir); } // Files that were being written when the datanode was last shutdown // should not be deleted. blocksBeingWritten = new File(parent, "blocksBeingWritten"); ... this.usage = new DF(parent, conf); this.dfsUsage = new DU(parent, conf); this.dfsUsage.start(); } //getDfsUsed getCapacity getAvailable long get*() throws IOException { return dfsUsage.get*(); } File addBlock(Block b, File f) throws IOException { //调用FSDir的addBlock File blockFile = dataDir.addBlock(b, f); File metaFile = getMetaFile(blockFile, b); // add 后，磁盘使用量增加 dfsUsage.incDfsUsed(b.getNumBytes() + metaFile.length()); return blockFile; } //当前FSVolume下的volumeMap void getVolumeMap(HashMap<Block, DatanodeBlockInfo> volumeMap) { dataDir.getVolumeMap(volumeMap, this); } }
八.DF DU
- DF被设计用来获取dirPath路径所在的磁盘的空间状态信息，对应的unix的shell脚本命令格式是：df -k path。
- DU类实现了unix的du命令，显示文件或目录dirPath占用磁盘空间的大小信息。
public class DF extends Shell { /** Default DF refresh interval. */ public static final long DF_INTERVAL_DEFAULT = 3 * 1000; private final String dirPath; //执行df命令所在工作目录 private final File dirFile; //执行df命令所在工作目录文件夹 private String filesystem; //磁盘设备名 private String mount; //磁盘挂载位置 //初始化dirPath and dirFile public DF(File path, long dfInterval) throws IOException { super(dfInterval); this.dirPath = path.getCanonicalPath(); this.dirFile = path.getCanonicalFile(); } //getCapacity getUsed getAvailable public long get*() { return dirFile.get*(); } } public class DU extends Shell { private String dirPath; //执行du命令所在工作目录 }
九.FSVolumeSet
- 管理一个DataNode下所有的FSVolume。
- FSVolume的重要方法
- getVolumeMap：获得FSVolume[]下所有block到DatanodeBlockInfo的映射关系，叠加FSVolume.getVolumeMap实现。
- getDfsUsed磁盘使用量 getCapacity磁盘大小 getRemaining磁盘可用量，叠加FSVolume.x实现。
//管理一个DataNode下所有的FSVolume static class FSVolumeSet { FSVolume[] volumes = null; int curVolume = 0; FSVolumeSet(FSVolume[] volumes) { this.volumes = volumes; } //向DataNode添加block时，根据blockSize，获取第一个大于blockSize的FSVolume synchronized FSVolume getNextVolume(long blockSize) throws IOException { // make sure we are not out of bounds if (curVolume >= volumes.length) { curVolume = 0; } int startVolume = curVolume; while (true) { FSVolume volume = volumes[curVolume]; curVolume = (curVolume + 1) % volumes.length; if (volume.getAvailable() > blockSize) { return volume; } //空间不足 if (curVolume == startVolume) { throw new DiskOutOfSpaceException("Insufficient space for an additional block"); } } } long get*() throws IOException { 叠加每个FSVolume } //所有FSVolume下的volumeMap synchronized void getVolumeMap(HashMap<Block, DatanodeBlockInfo> volumeMap) { for (int idx = 0; idx < volumes.length; idx++) { volumes[idx].getVolumeMap(volumeMap); } } }
十.ActiveFile
ActiveFile对象保存了一个文件，和操作这个文件的线程，线程有可能有多个。
static class ActiveFile {
final File file;
final List<Thread> threads = new ArrayList<Thread>(2);
//初始化ActiveFile时会自动地把当前线程加入其中
ActiveFile(File f, List<Thread> list) {
this(f, false);
if (list != null) {
threads.addAll(list);
}
threads.add(Thread.currentThread());
}
}
十一.FSDataset
- FSDataset manages a set of data blocks.通过FSVolumeSet 管理。
- FSDataset实现了FSDatasetInterface接口，FSDatasetInterface接口是DataNode对底层存储的抽象。
public class FSDataset implements FSConstants, FSDatasetInterface { //所有FSVolume FSVolumeSet volumes; //所有Block到DatanodeBlockInfo的映射 HashMap<Block, DatanodeBlockInfo> volumeMap = new HashMap<Block, DatanodeBlockInfo>();; //所有Block到ActiveFile的映射，也就是说，说有正在创建的Block，都会记录在ongoingCreates里。 private HashMap<Block, ActiveFile> ongoingCreates = new HashMap<Block, ActiveFile>(); //初始化FSDataset时初始化volumes and volumeMap public FSDataset(DataStorage storage, Configuration conf)throws IOException { FSVolume[] volArray = new FSVolume[storage.getNumStorageDirs()]; for (int idx = 0; idx < storage.getNumStorageDirs(); idx++) { volArray[idx] = new FSVolume(storage.getStorageDir(idx) .getCurrentDir(), conf); } volumes = new FSVolumeSet(volArray); volumes.getVolumeMap(volumeMap); } //=================================== 根据block 的几个方法 开始=================================== //得到block文件 public synchronized File getBlockFile(Block b) throws IOException ; //得到block元文件 protected File getMetaFile(Block b) throws IOException ; //得到block的元数据长度。 public long getMetaDataLength(Block b) throws IOException ; //得到InputStream MetaDataInputStream包含block长度 public MetaDataInputStream getMetaDataInputStream(Block b) throws IOException; //得到block对应元数据文件的inputstream public InputStream getBlockInputStream(Block b) throws IOException //获得block对应元数据文件的inputstream， 从指定位置开始读 public InputStream getBlockInputStream(Block b, long seekOffset) throws IOException; //得到Block的临时输入流。注意，临时输入流是指对应的文件处于tmp目录中。 //新创建块时，块数据应该写在tmp目录中，直到写操作成功，文件才会被移动到current目录中，如果失败，就不会影响current目录了。简单方法。 public BlockInputStreams getTmpInputStreams(Block b, long blkoff, long ckoff) throws IOException; //得到一个block的输出流。BlockWriteStreams既包含了数据输出流，也包含了元数据（校验文件）输出流。 //参数isRecovery说明这次写是不是对以前失败的写的一次恢复操作。 //正常的写操作流程：首先，如果输入的block是个正常的数据块，或当前的block已经有线程在写，writeToBlock会抛出一个异常。 //否则，将创建相应的临时数据文件和临时元数据文件，并把相关信息，创建一个ActiveFile对象，记录到ongoingCreates中，并创建返回的BlockWriteStreams。 //前面我们已经提过，建立新的ActiveFile时，当前线程会自动保存在ActiveFile的threads中。 //以blk_3148782637964391313为例， //当DataNode需要为Block ID为3148782637964391313创建写流时，DataNode创建文件tmp/blk_3148782637964391313做为临时数据文件， //对应的meta文件是tmp/blk_3148782637964391313_XXXXXX.meta。其中XXXXXX是版本号。 //isRecovery为true时，表明我们需要从某一次不成功的写中恢复，流程相对于正常流程复杂。 //如果不成功的写是由于提交（参考finalizeBlock方法）后的确认信息没有收到，先创建一个detached文件（备份）。 //接着，writeToBlock检查是否有还有对文件写的线程，如果有，则通过线程的interrupt方法，强制结束线程。这就是说，如果有线程还在写对应的文件块，该线程将被终止。 //同时，从ongoingCreates中移除对应的信息。接下来将根据临时文件是否存在，创建/复用临时数据文件和临时数据元文件。 //后续操作就和正常流程一样，根据相关信息，创建一个ActiveFile对象，记录到ongoingCreates中 public BlockWriteStreams writeToBlock(Block b, boolean isRecovery, boolean isReplicationRequest) throws IOException; //提交（或叫：结束finalize）通过writeToBlock打开的block，这意味着写过程没有出错，可以正式把Block从tmp文件夹放到current文件夹。 //将从ongoingCreates中删除对应的block，同时将block对应的DatanodeBlockInfo，放入volumeMap中。 //以blk_3148782637964391313为例，当DataNode提交Block ID为3148782637964391313数据块文件时，DataNode将把tmp/blk_3148782637964391313移到current下某一个目录， //以subdir12为例，这是tmp/blk_3148782637964391313将会挪到current/subdir12/blk_3148782637964391313。对应的meta文件也在目录current/subdir12下。 public void finalizeBlock(Block b) throws IOException; //更新一个block。 //updateBlock的最外层是一个死循环，循环的结束条件，是没有任何和这个数据块相关的写线程。 //每次循环，updateBlock都会去调用一个叫tryUpdateBlock的内部方法。 //tryUpdateBlock发现已经没有线程在写这个块，就会跟新和这个数据块相关的信息，包括元文件和内存中的映射表volumeMap。 //如果tryUpdateBlock发现还有活跃的线程和该块关联，那么，updateBlock会试图结束该线程，并等在join上等待。 public void updateBlock(Block oldblock, Block newblock) throws IOException; //取消通过writeToBlock打开的block，与finalizeBlock方法作用相反。 public void unfinalizeBlock(Block b) throws IOException; //=================================== 根据block 的几个方法 结束=================================== //getDfsUsed getCapacity getRemaining public long get*() throws IOException { return volumes.get*(); } }