Hadoop-0.20.0源代码分析（08）

这里，继续对FsShell类中一些命令进行阅读分析，主要是看与拷贝文件有关的几个命令。

cp命令

该命令实现对文件的拷贝操作，并且支持在不同的文件系统之间进行文件的拷贝。拷贝文件涉及的操作比较复杂，核心拷贝操作还是调用了org.apache.hadoop.fs.FileUtil类的copy方法实现的。 先看该类中定义的其中一个copy方法的实现：

private int copy(String argv[], Configuration conf) throws IOException {
int i = 0;
int exitCode = 0;
String cmd = argv[i++];
String dest = argv[argv.length-1]; // 命令行中最后一个参数
// 若指定了多个输入源文件，则最后一个参数必须是一个目录
if (argv.length > 3) {
Path dst = new Path(dest);
if (!fs.isDirectory(dst)) { // 最后一个参数必须是目录
throw new IOException("When copying multiple files, " + "destination " + dest + " should be a directory.");
}
}
// 循环对每一个文件进行拷贝操作
for (; i < argv.length - 1; i++) {
try {
copy(argv[i], dest, conf); // 将文件argv[i]拷贝到dest目录中
} catch (RemoteException e) {
// 捕获命令执行发生的异常信息
exitCode = -1;
try {
String[] content;
content = e.getLocalizedMessage().split("/n");
System.err.println(cmd.substring(1) + ": " +
content[0]);
} catch (Exception ex) {
System.err.println(cmd.substring(1) + ": " +
ex.getLocalizedMessage());
}
} catch (IOException e) {
// 捕获IO异常信息
exitCode = -1;
System.err.println(cmd.substring(1) + ": " + e.getLocalizedMessage());
}
}
return exitCode;
}

该命令的实现与mv命令类似，这里调用了一个重载的copy命令，实现对一个文件执行拷贝操作。该重载的拷贝方法如下所示：

void copy(String srcf, String dstf, Configuration conf) throws IOException {
Path srcPath = new Path(srcf); // 构造Path
FileSystem srcFs = srcPath.getFileSystem(getConf()); // 获取到srcPath所在的文件系统srcFs
Path dstPath = new Path(dstf);
FileSystem dstFs = dstPath.getFileSystem(getConf()); // 获取到dstPath所在的文件系统dstFs
Path [] srcs = FileUtil.stat2Paths(srcFs.globStatus(srcPath), srcPath); // 获取到srcFs中满足srcPath模式的FileStatus[]并转换成为Path[]
if (srcs.length > 1 && !dstFs.isDirectory(dstPath)) {
throw new IOException("When copying multiple files, " + "destination should be a directory.");
}
for(int i=0; i<srcs.length; i++) { // 循环拷贝操作
FileUtil.copy(srcFs, srcs[i], dstFs, dstPath, false, conf); // 调用FileUtil类的拷贝方法copy完成文件在srcFs与dstFs文件系统之间拷贝文件的操作
}
}

现在，我们开始追踪 org.apache.hadoop.fs.FileUtil类的copy方法，看一看拷贝到底是如何实现的。FileUtil类中定义了多个重载的拷贝方法copy，我们只从FsShell类中调用的copy方法开始追踪其实现。上面调用的FileUtil类的copy实现如下所示：

public static boolean copy(FileSystem srcFS, Path src,
FileSystem dstFS, Path dst,
boolean deleteSource,
Configuration conf) throws IOException {
return copy(srcFS, src, dstFS, dst, deleteSource, true, conf); // 调用了一个重载的copy方法实现文件在srcFS与dstFS之间进行复制
}

看重载的copy方法的实现，如下所示：

public static boolean copy(FileSystem srcFS, Path src,
FileSystem dstFS, Path dst,
boolean deleteSource,
boolean overwrite,
Configuration conf) throws IOException {
dst = checkDest(src.getName(), dstFS, dst, overwrite); // 检查目的文件系统dstFS中dst目录是否合法（参照src）
if (srcFS.getFileStatus(src).isDir()) { // 若源文件系统srcFS中src是目录
checkDependencies(srcFS, src, dstFS, dst); // 检查文件依赖性：如果srcFS=dstFS，并且dst不是src的子目录，检查通过；如果srcFS与dstFS不是同一个文件系统，依赖性检查通过
if (!dstFS.mkdirs(dst)) { // 在dstFS中创建dst目录，准备向其中拷贝数据
return false;
}
FileStatus contents[] = srcFS.listStatus(src); // 获取srcFS中src目录下的文件列表
for (int i = 0; i < contents.length; i++) { // 分治思想：分治后执行递归拷贝文件操作
copy(srcFS, contents[i].getPath(), dstFS,
new Path(dst, contents[i].getPath().getName()),
deleteSource, overwrite, conf); // 递归调用
}
} else if (srcFS.isFile(src)) { // 递归出口（如果src是一个普通文件）
InputStream in=null;
OutputStream out = null;
try {
in = srcFS.open(src); // 打开srcFS中的src文件，并返回输入流对象
out = dstFS.create(dst, overwrite); // 在目的文件系统dstFS中创建dst文件，并返回输出流，等待写入
IOUtils.copyBytes(in, out, conf, true); // 调用：通过调用IOUtils类的copyBytes方法实现流式拷贝
} catch (IOException e) {
IOUtils.closeStream(out); // 关闭out
IOUtils.closeStream(in); // 关闭in
throw e;
}
} else {
throw new IOException(src.toString() + ": No such file or directory");
}
if (deleteSource) { // 如果设置了拷贝完成后删除源文件选项
return srcFS.delete(src, true); // 删除源文件系统srcFS的源文件src
} else {
return true;
}

}

IOUtils类中实现了Hadoop文件系统中文件的 流式拷贝操作，我们追踪该工具类的copyBytes方法，分析实现的过程。该方法如下所示：

/**
* 从一个流拷贝到另一个流中
*/
public static void copyBytes(InputStream in, OutputStream out, Configuration conf, boolean close)
throws IOException {
copyBytes(in, out, conf.getInt("io.file.buffer.size", 4096),  close); // 调用：重载的copyBytes方法实现流式拷贝
}

我们看重载流式拷贝实现方法copyBytes，如下所示：

public static void copyBytes(InputStream in, OutputStream out, int buffSize, boolean close) throws IOException {
PrintStream ps = out instanceof PrintStream ? (PrintStream)out : null; // 使用PrintStream为out流增加便捷功能
byte buf[] = new byte[buffSize]; // 字节缓冲区
try {
int bytesRead = in.read(buf); // 从输入流in读取bytesRead个字节到buf缓冲区中
while (bytesRead >= 0) { // 确实读取到了字节
out.write(buf, 0, bytesRead); // 将从in中读取到的字节，通过buf缓冲区写入到输出流out中
if ((ps != null) && ps.checkError()) { // 如果ps=(PrintStream)out，测试内部标志，并自动刷新
throw new IOException("Unable to write to output stream.");
}
bytesRead = in.read(buf); // 继续从in读取字节
}
} finally {
if(close) {
out.close(); // 关闭out
in.close(); // 关闭in
}
}
}

上面在从InputStream in拷贝到OutputStream out中的过程中，使用了更加高效的PrintStream流类，它能够为OutputStream增加方便打印各种数据值的表示形式，而且，它不会抛出IO异常，而是将流式拷贝过程中发生的异常，设置为通过调用checkError方法来检测内部的标志。另外，它还可以实现自动刷新，在向输出流中写入字节（通过字节缓冲区）之后，自动刷新。

cp命令的具体实现都在上面进行分析了，应该能够理解在Hadoop中如何在不同文件系统之间执行流式拷贝文件的过程。

copyFromLocal命令

该命令实现了从本地文件系统拷贝文件的操作。实现方法为，如下所示：

/**
* 从本地文件系统（srcs在本地文件系统中）拷贝srcs到目的文件系统（对应Path为dstf）
*/
void copyFromLocal(Path[] srcs, String dstf) throws IOException {
Path dstPath = new Path(dstf);
FileSystem dstFs = dstPath.getFileSystem(getConf()); // 获取到目的文件系统dstFs
if (srcs.length == 1 && srcs[0].toString().equals("-")) // 如果只指定了一个参数“-”
copyFromStdin(dstPath, dstFs); // 调用：从标准输入流中进行流式拷贝操作
else // 否则
dstFs.copyFromLocalFile(false, false, srcs, dstPath); // 调用目的文件系统dstFs的copyFromLocalFile方法执行拷贝操作
}

我们关注一下copyFromStdin方法拷贝的实现，如下所示：

private void copyFromStdin(Path dst, FileSystem dstFs) throws IOException {
if (dstFs.isDirectory(dst)) { // 如果目的文件是目录，不支持源为标准输入流的情况
throw new IOException("When source is stdin, destination must be a file.");
}
if (dstFs.exists(dst)) { // 如果目的文件系统dstFs中存在文件dst，出错
throw new IOException("Target " + dst.toString() + " already exists.");
}
FSDataOutputStream out = dstFs.create(dst); // 满足拷贝要求，执行流式拷贝操作
try {
IOUtils.copyBytes(System.in, out, getConf(), false); // 调用IOUtils类的copyBytes方法实现，前面已经分析过拷贝过程
}
finally {
out.close(); // 拷贝完成，关闭输出流out
}
}

再看一下，如果指定的是待拷贝的文件源不是标准输入流的情况，文件系统FileSystem是如何实现拷贝操作的。实现的方法copyFromLocalFile如下所示：

/**
* 将本地的srcs，拷贝到目的文件系统中的dst
* delSrc指示了拷贝文件完成之后，是否删除源文件srcs
*/
public void copyFromLocalFile(boolean delSrc, boolean overwrite, Path[] srcs, Path dst)
throws IOException {
Configuration conf = getConf();
FileUtil.copy(getLocal(conf), srcs, this, dst, delSrc, overwrite, conf); // 调用FileUtil工具类实现拷贝操作
}

关于FileUtil的copy方法，前面已经详细分析过，不再累述。

像moveFromLocal、moveFromLocal、copyToLocal、moveToLocal、copyMergeToLocal等命令的实现都非常类似，也不做过多的解释了。