package com.study.hdfs; 
 
import org.apache.commons.io.IOUtils; 
import org.apache.hadoop.conf.Configuration; 
import org.apache.hadoop.fs.BlockLocation; 
import org.apache.hadoop.fs.FSDataInputStream; 
import org.apache.hadoop.fs.FSDataOutputStream; 
import org.apache.hadoop.fs.FileStatus; 
import org.apache.hadoop.fs.FileSystem; 
import org.apache.hadoop.fs.LocatedFileStatus; 
import org.apache.hadoop.fs.Path; 
import org.apache.hadoop.fs.RemoteIterator; 
import org.apache.hadoop.hdfs.DistributedFileSystem; 
import org.apache.hadoop.hdfs.protocol.DatanodeInfo; 
import org.junit.AfterClass; 
import org.junit.BeforeClass; 
import org.junit.Test; 
 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.net.URI; 
import java.net.URISyntaxException; 
import java.util.Iterator; 
import java.util.Map; 
 
/** 
 * @author wangxu 
 * @date 2016/12/17 
 */ 
public class HDFSTest { 
     
    private static FileSystem fs; 
     
    @BeforeClass 
    public static void setup() throws URISyntaxException, IOException, InterruptedException { 
        //方式1通过配置来获取fs 
        /*Configuration conf = new Configuration(); 
        conf.set("fs.defaultFS", "hdfs://node1:9000"); 
        FileSystem fs = FileSystem.get(conf); 
        System.setProperty("HADOOP_USER_NAME", "root");*/ 
        //方式2直接获取fs 
        Configuration conf = new Configuration(); 
        conf.set("dfs.replication", "2"); 
        conf.set("dfs.block.size", "64m"); 
        fs = FileSystem.get(new URI("hdfs://node1:9000"), conf, "root"); 
    } 
     
     
    @Test 
    public void test01() throws IOException { 
        fs.copyToLocalFile(new Path("/plans.txt"),new Path("C:/Users/wxisme/Desktop/bigdatatest/")); 
    } 
     
    @Test 
    public void test02() throws IOException { 
        FSDataOutputStream out = fs.create(new Path("/plans01.txt")); 
        FileInputStream in = new FileInputStream("C:/Users/wxisme/Desktop/bigdatatest/plans.txt"); 
         
        IOUtils.copy(in, out); 
    } 
     
    @Test 
    public void test03() throws IOException { 
        DatanodeInfo[] dataNodeStats = ((DistributedFileSystem)fs).getDataNodeStats(); 
        for(DatanodeInfo dinfo: dataNodeStats){ 
            System.out.println(dinfo.getHostName()); 
        } 
    } 
     
    @Test 
    public void test04() throws IOException { 
//        fs.mkdirs(new Path("/wangxu/study")); 
//        fs.rename(new Path("/wangxu/study"), new Path("/wangxu/play")); 
        fs.delete(new Path("/wangxu/play"), true); 
    } 
     
    @Test 
    public void test05() throws IOException { 
        //返回迭代器，而不是List之类的容器,防止客户端内存溢出 
        RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(new Path("/"), true); 
        while (listFiles.hasNext()) { 
             
            LocatedFileStatus fileStatus = listFiles.next(); 
             
            System.out.println(fileStatus.getPath().getName()); 
            System.out.println(fileStatus.getBlockSize()); 
            System.out.println(fileStatus.getPermission()); 
            System.out.println(fileStatus.getLen()); 
            BlockLocation[] blockLocations = fileStatus.getBlockLocations(); 
            for (BlockLocation bl : blockLocations) { 
                System.out.println("block-length:" + bl.getLength() + "--" + "block-offset:" + bl.getOffset()); 
                String[] hosts = bl.getHosts(); 
                for (String host : hosts) { 
                    System.out.println(host); 
                } 
            } 
             
            System.out.println("--------------分割线--------------"); 
             
        } 
    } 
     
    @Test 
    public void test06() throws IOException { 
        FileStatus[] listStatus = fs.listStatus(new Path("/")); 
         
        String flag = ""; 
        for (FileStatus fstatus : listStatus) { 
             
            if (fstatus.isFile()) { 
                flag = "f-- "; 
            } else { 
                flag = "d-- "; 
            } 
            System.out.println(flag + fstatus.getPath().getName()); 
            System.out.println(fstatus.getPermission()); 
             
        } 
    } 
     
     
    @Test 
    public void test07() { 
        Configuration conf = new Configuration(); 
        conf.addResource("test.xml"); 
        System.out.println(conf.get("xxx.uu")); 
 
        Iterator<Map.Entry<String, String>> it = conf.iterator(); 
 
        while(it.hasNext()){ 
 
            System.out.println(it.next()); 
 
        } 
    } 
     
    @Test 
    public void testDownLoadFileToLocal() throws IllegalArgumentException, IOException{ 
         
        //先获取一个文件的输入流----针对hdfs上的 
        FSDataInputStream in = fs.open(new Path("/jdk-7u65-linux-i586.tar.gz")); 
         
        //再构造一个文件的输出流----针对本地的 
        FileOutputStream out = new FileOutputStream(new File("c:/jdk.tar.gz")); 
         
        //再将输入流中数据传输到输出流 
        org.apache.hadoop.io.IOUtils.copyBytes(in, out, 4096); 
         
         
    } 
     
    @Test 
    public void testUploadByStream() throws Exception{ 
         
        //hdfs文件的输出流 
        FSDataOutputStream fsout = fs.create(new Path("/aaa.txt")); 
         
        //本地文件的输入流 
        FileInputStream fsin = new FileInputStream("c:/111.txt"); 
         
        org.apache.hadoop.io.IOUtils.copyBytes(fsin, fsout,4096); 
         
         
    } 
     
     
     
     
    /** 
     * hdfs支持随机定位进行文件读取，而且可以方便地读取指定长度 
     * 用于上层分布式运算框架并发处理数据 
     * @throws IllegalArgumentException 
     * @throws IOException 
     */ 
    @Test 
    public void testRandomAccess() throws IllegalArgumentException, IOException{ 
        //先获取一个文件的输入流----针对hdfs上的 
        FSDataInputStream in = fs.open(new Path("/iloveyou.txt")); 
         
         
        //可以将流的起始偏移量进行自定义 
        in.seek(22); 
         
        //再构造一个文件的输出流----针对本地的 
        FileOutputStream out = new FileOutputStream(new File("d:/iloveyou.line.2.txt")); 
         
        org.apache.hadoop.io.IOUtils.copyBytes(in,out,19L,true); 
         
    } 
     
     
     
    /** 
     * 读取指定的block 
     * @throws IOException 
     * @throws IllegalArgumentException 
     */ 
    @Test 
    public void testCat() throws IllegalArgumentException, IOException{ 
         
        FSDataInputStream in = fs.open(new Path("/weblog/input/access.log.10")); 
        //拿到文件信息 
        FileStatus[] listStatus = fs.listStatus(new Path("/weblog/input/access.log.10")); 
        //获取这个文件的所有block的信息 
        BlockLocation[] fileBlockLocations = fs.getFileBlockLocations(listStatus[0], 0L, listStatus[0].getLen()); 
         
         
        //第一个block的长度 
        long length = fileBlockLocations[0].getLength(); 
        //第一个block的起始偏移量 
        long offset = fileBlockLocations[0].getOffset(); 
         
        System.out.println(length); 
        System.out.println(offset); 
         
        //获取第一个block写入输出流 
//        IOUtils.copyBytes(in, System.out, (int)length); 
        byte[] b = new byte[4096]; 
         
        FileOutputStream os = new FileOutputStream(new File("d:/block0")); 
        while(in.read(offset, b, 0, 4096)!=-1){ 
            os.write(b); 
            offset += 4096; 
            if(offset>length) return; 
        }; 
         
        os.flush(); 
        os.close(); 
        in.close(); 
    } 
     
     
    @AfterClass 
    public static void shutdown() throws IOException { 
        fs.close(); 
    } 
     
}