TestHDFSServerPorts.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:8k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.hdfs;
  19. import java.io.File;
  20. import java.io.IOException;
  21. import junit.framework.TestCase;
  22. import org.apache.hadoop.conf.Configuration;
  23. import org.apache.hadoop.fs.FileSystem;
  24. import org.apache.hadoop.fs.FileUtil;
  25. import org.apache.hadoop.hdfs.server.datanode.DataNode;
  26. import org.apache.hadoop.hdfs.server.namenode.NameNode;
  27. import org.apache.hadoop.hdfs.server.namenode.SecondaryNameNode;
  28. import org.apache.hadoop.ipc.RPC;
  29. /**
  30.  * This test checks correctness of port usage by hdfs components:
  31.  * NameNode, DataNode, and SecondaryNamenode.
  32.  * 
  33.  * The correct behavior is:<br> 
  34.  * - when a specific port is provided the server must either start on that port 
  35.  * or fail by throwing {@link java.net.BindException}.<br>
  36.  * - if the port = 0 (ephemeral) then the server should choose 
  37.  * a free port and start on it.
  38.  */
  39. public class TestHDFSServerPorts extends TestCase {
  40.   public static final String NAME_NODE_HOST = "localhost:";
  41.   public static final String NAME_NODE_HTTP_HOST = "0.0.0.0:";
  42.   Configuration config;
  43.   File hdfsDir;
  44.   /**
  45.    * Start the name-node.
  46.    */
  47.   public NameNode startNameNode() throws IOException {
  48.     String dataDir = System.getProperty("test.build.data");
  49.     hdfsDir = new File(dataDir, "dfs");
  50.     if ( hdfsDir.exists() && !FileUtil.fullyDelete(hdfsDir) ) {
  51.       throw new IOException("Could not delete hdfs directory '" + hdfsDir + "'");
  52.     }
  53.     config = new Configuration();
  54.     config.set("dfs.name.dir", new File(hdfsDir, "name1").getPath());
  55.     FileSystem.setDefaultUri(config, "hdfs://"+NAME_NODE_HOST + "0");
  56.     config.set("dfs.http.address", NAME_NODE_HTTP_HOST + "0");
  57.     NameNode.format(config);
  58.     String[] args = new String[] {};
  59.     // NameNode will modify config with the ports it bound to
  60.     return NameNode.createNameNode(args, config);
  61.   }
  62.   /**
  63.    * Start the data-node.
  64.    */
  65.   public DataNode startDataNode(int index, Configuration config) 
  66.   throws IOException {
  67.     String dataDir = System.getProperty("test.build.data");
  68.     File dataNodeDir = new File(dataDir, "data-" + index);
  69.     config.set("dfs.data.dir", dataNodeDir.getPath());
  70.     String[] args = new String[] {};
  71.     // NameNode will modify config with the ports it bound to
  72.     return DataNode.createDataNode(args, config);
  73.   }
  74.   /**
  75.    * Stop the datanode.
  76.    */
  77.   public void stopDataNode(DataNode dn) {
  78.     if (dn != null) {
  79.       dn.shutdown();
  80.     }
  81.   }
  82.   public void stopNameNode(NameNode nn) {
  83.     if (nn != null) {
  84.       nn.stop();
  85.     }
  86.   }
  87.   public Configuration getConfig() {
  88.     return this.config;
  89.   }
  90.   /**
  91.    * Check whether the name-node can be started.
  92.    */
  93.   private boolean canStartNameNode(Configuration conf) throws IOException {
  94.     NameNode nn2 = null;
  95.     try {
  96.       nn2 = NameNode.createNameNode(new String[]{}, conf);
  97.     } catch(IOException e) {
  98.       if (e instanceof java.net.BindException)
  99.         return false;
  100.       throw e;
  101.     }
  102.     stopNameNode(nn2);
  103.     return true;
  104.   }
  105.   /**
  106.    * Check whether the data-node can be started.
  107.    */
  108.   private boolean canStartDataNode(Configuration conf) throws IOException {
  109.     DataNode dn = null;
  110.     try {
  111.       dn = DataNode.createDataNode(new String[]{}, conf);
  112.     } catch(IOException e) {
  113.       if (e instanceof java.net.BindException)
  114.         return false;
  115.       throw e;
  116.     }
  117.     dn.shutdown();
  118.     return true;
  119.   }
  120.   /**
  121.    * Check whether the secondary name-node can be started.
  122.    */
  123.   private boolean canStartSecondaryNode(Configuration conf) throws IOException {
  124.     SecondaryNameNode sn = null;
  125.     try {
  126.       sn = new SecondaryNameNode(conf);
  127.     } catch(IOException e) {
  128.       if (e instanceof java.net.BindException)
  129.         return false;
  130.       throw e;
  131.     }
  132.     sn.shutdown();
  133.     return true;
  134.   }
  135.   /**
  136.    * Verify name-node port usage.
  137.    */
  138.   public void testNameNodePorts() throws Exception {
  139.     NameNode nn = null;
  140.     try {
  141.       nn = startNameNode();
  142.       // start another namenode on the same port
  143.       Configuration conf2 = new Configuration(config);
  144.       conf2.set("dfs.name.dir", new File(hdfsDir, "name2").getPath());
  145.       NameNode.format(conf2);
  146.       boolean started = canStartNameNode(conf2);
  147.       assertFalse(started); // should fail
  148.       // start on a different main port
  149.       FileSystem.setDefaultUri(conf2, "hdfs://"+NAME_NODE_HOST + "0");
  150.       started = canStartNameNode(conf2);
  151.       assertFalse(started); // should fail again
  152.       // reset conf2 since NameNode modifies it
  153.       FileSystem.setDefaultUri(conf2, "hdfs://"+NAME_NODE_HOST + "0");
  154.       // different http port
  155.       conf2.set("dfs.http.address", NAME_NODE_HTTP_HOST + "0");
  156.       started = canStartNameNode(conf2);
  157.       assertTrue(started); // should start now
  158.     } finally {
  159.       stopNameNode(nn);
  160.     }
  161.   }
  162.   /**
  163.    * Verify data-node port usage.
  164.    */
  165.   public void testDataNodePorts() throws Exception {
  166.     NameNode nn = null;
  167.     try {
  168.       nn = startNameNode();
  169.       // start data-node on the same port as name-node
  170.       Configuration conf2 = new Configuration(config);
  171.       conf2.set("dfs.data.dir", new File(hdfsDir, "data").getPath());
  172.       conf2.set("dfs.datanode.address",
  173.                 FileSystem.getDefaultUri(config).getAuthority());
  174.       conf2.set("dfs.datanode.http.address", NAME_NODE_HTTP_HOST + "0");
  175.       boolean started = canStartDataNode(conf2);
  176.       assertFalse(started); // should fail
  177.       // bind http server to the same port as name-node
  178.       conf2.set("dfs.datanode.address", NAME_NODE_HOST + "0");
  179.       conf2.set("dfs.datanode.http.address", 
  180.                 config.get("dfs.http.address"));
  181.       started = canStartDataNode(conf2);
  182.       assertFalse(started); // should fail
  183.     
  184.       // both ports are different from the name-node ones
  185.       conf2.set("dfs.datanode.address", NAME_NODE_HOST + "0");
  186.       conf2.set("dfs.datanode.http.address", NAME_NODE_HTTP_HOST + "0");
  187.       conf2.set("dfs.datanode.ipc.address", NAME_NODE_HOST + "0");
  188.       started = canStartDataNode(conf2);
  189.       assertTrue(started); // should start now
  190.     } finally {
  191.       stopNameNode(nn);
  192.     }
  193.   }
  194.   /**
  195.    * Verify secondary name-node port usage.
  196.    */
  197.   public void testSecondaryNodePorts() throws Exception {
  198.     NameNode nn = null;
  199.     try {
  200.       nn = startNameNode();
  201.       // bind http server to the same port as name-node
  202.       Configuration conf2 = new Configuration(config);
  203.       conf2.set("dfs.secondary.http.address", 
  204.                 config.get("dfs.http.address"));
  205.       SecondaryNameNode.LOG.info("= Starting 1 on: " + 
  206.                                  conf2.get("dfs.secondary.http.address"));
  207.       boolean started = canStartSecondaryNode(conf2);
  208.       assertFalse(started); // should fail
  209.       // bind http server to a different port
  210.       conf2.set("dfs.secondary.http.address", NAME_NODE_HTTP_HOST + "0");
  211.       SecondaryNameNode.LOG.info("= Starting 2 on: " + 
  212.                                  conf2.get("dfs.secondary.http.address"));
  213.       started = canStartSecondaryNode(conf2);
  214.       assertTrue(started); // should start now
  215.     } finally {
  216.       stopNameNode(nn);
  217.     }
  218.   }
  219. }