HADOOP-1762. The Namenode fsimage does not contain the list of

Datanodes.  (Raghu Angadi via dhruba)



git-svn-id: https://svn.apache.org/repos/asf/lucene/hadoop/trunk@576729 13f79535-47bb-0310-9956-ffa450edef68

CHANGES.txt

@@ -83,6 +83,9 @@ Trunk (unreleased changes)
 
   BUG FIXES
 
+    HADOOP-1762. The Namenode fsimage does not contain a list of
+    Datanodes.  (Raghu Angadi via dhruba)
+
     HADOOP-1890. Removed debugging prints introduced by HADOOP-1774.
     (Raghu Angadi via dhruba)
 

src/java/org/apache/hadoop/dfs/DataNode.java

@@ -36,6 +36,8 @@ import org.apache.hadoop.dfs.DatanodeProtocol;
 import java.io.*;
 import java.net.*;
 import java.util.*;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
 import org.apache.hadoop.metrics.MetricsContext;
 import org.apache.hadoop.metrics.MetricsRecord;
 import org.apache.hadoop.metrics.Updater;
@@ -337,6 +339,36 @@ public class DataNode implements FSConstants, Runnable {
     return "<namenode>";
   }
 
+  private void setNewStorageID(DatanodeRegistration dnReg) {
+    /* Return 
+     * "DS-randInt-ipaddr-currentTimeMillis"
+     * It is considered extermely rare for all these numbers to match
+     * on a different machine accidentally for the following 
+     * a) SecureRandom(INT_MAX) is pretty much random (1 in 2 billion), and
+     * b) Good chance ip address would be different, and
+     * c) Even on the same machine, Datanode is designed to use different ports.
+     * d) Good chance that these are started at different times.
+     * For a confict to occur all the 4 above have to match!.
+     * The format of this string can be changed anytime in future without
+     * affecting its functionality.
+     */
+    String ip = "unknownIP";
+    try {
+      ip = DNS.getDefaultIP("default");
+    } catch (UnknownHostException ignored) {
+      LOG.warn("Could not find ip address of \"default\" inteface.");
+    }
+    
+    int rand = 0;
+    try {
+      rand = SecureRandom.getInstance("SHA1PRNG").nextInt(Integer.MAX_VALUE);
+    } catch (NoSuchAlgorithmException e) {
+      LOG.warn("Could not use SecureRandom");
+      rand = (new Random()).nextInt(Integer.MAX_VALUE);
+    }
+    dnReg.storageID = "DS-" + rand + "-"+ ip + "-" + dnReg.getPort() + "-" + 
+                      System.currentTimeMillis();
+  }
   /**
    * Register datanode
    * <p>
@@ -349,6 +381,9 @@ public class DataNode implements FSConstants, Runnable {
    * @throws IOException
    */
   private void register() throws IOException {
+    if (dnRegistration.getStorageID().equals("")) {
+      setNewStorageID(dnRegistration);
+    }
     while(shouldRun) {
       try {
         // reset name to machineName. Mainly for web interface.

src/java/org/apache/hadoop/dfs/FSEditLog.java

@@ -43,8 +43,9 @@ class FSEditLog {
   private static final byte OP_DELETE = 2;
   private static final byte OP_MKDIR = 3;
   private static final byte OP_SET_REPLICATION = 4;
-  private static final byte OP_DATANODE_ADD = 5;
-  private static final byte OP_DATANODE_REMOVE = 6;
+  //the following two are used only for backword compatibility :
+  @Deprecated private static final byte OP_DATANODE_ADD = 5;
+  @Deprecated private static final byte OP_DATANODE_REMOVE = 6;
 
   private ArrayList<EditLogOutputStream> editStreams = null;
   private FSImage fsimage = null;
@@ -383,8 +384,7 @@ class FSEditLog {
                                     + " for version " + logVersion);
             FSImage.DatanodeImage nodeimage = new FSImage.DatanodeImage();
             nodeimage.readFields(in);
-            DatanodeDescriptor node = nodeimage.getDatanodeDescriptor();
-            fsNamesys.unprotectedAddDatanode(node);
+            //Datnodes are not persistent any more.
             break;
           }
           case OP_DATANODE_REMOVE: {
@@ -394,11 +394,7 @@ class FSEditLog {
             DatanodeID nodeID = new DatanodeID();
             nodeID.readFields(in);
             DatanodeDescriptor node = fsNamesys.getDatanode(nodeID);
-            if (node != null) {
-              fsNamesys.unprotectedRemoveDatanode(node);
-              // physically remove node from datanodeMap
-              fsNamesys.wipeDatanode(nodeID);
-            }
+            //Datanodes are not persistent any more.
             break;
           }
           default: {
@@ -552,22 +548,6 @@ class FSEditLog {
     logEdit(OP_DELETE, new ArrayWritable(UTF8.class, info), null);
   }
   
-  /** 
-   * Creates a record in edit log corresponding to a new data node
-   * registration event.
-   */
-  void logAddDatanode(DatanodeDescriptor node) {
-    logEdit(OP_DATANODE_ADD, new FSImage.DatanodeImage(node), null);
-  }
-  
-  /** 
-   * Creates a record in edit log corresponding to a data node
-   * removal event.
-   */
-  void logRemoveDatanode(DatanodeID nodeID) {
-    logEdit(OP_DATANODE_REMOVE, new DatanodeID(nodeID), null);
-  }
-  
   static UTF8 toLogReplication(short replication) {
     return new UTF8(Short.toString(replication));
   }

src/java/org/apache/hadoop/dfs/FSImage.java

@@ -850,32 +850,25 @@ class FSImage extends Storage {
   }
 
   /**
-   * Save list of datanodes contained in {@link FSNamesystem#datanodeMap}.
-   * Only the {@link DatanodeInfo} part is stored.
-   * The {@link DatanodeDescriptor#blocks} is transient.
+   * Earlier version used to store all the known datanodes.
+   * DFS don't store datanodes anymore.
    * 
    * @param out output stream
    * @throws IOException
    */
   void saveDatanodes(DataOutputStream out) throws IOException {
-    Map datanodeMap = FSNamesystem.getFSNamesystem().datanodeMap;
-    int size = datanodeMap.size();
-    out.writeInt(size);
-    for(Iterator it = datanodeMap.values().iterator(); it.hasNext();) {
-      DatanodeImage nodeImage = new DatanodeImage((DatanodeDescriptor) it.next());
-      nodeImage.write(out);
-    }
+    // we don't store datanodes anymore.
+    out.writeInt(0);    
   }
 
   void loadDatanodes(int version, DataInputStream in) throws IOException {
     if (version > -3) // pre datanode image version
       return;
-    FSNamesystem fsNamesys = FSNamesystem.getFSNamesystem();
     int size = in.readInt();
     for(int i = 0; i < size; i++) {
       DatanodeImage nodeImage = new DatanodeImage();
       nodeImage.readFields(in);
-      fsNamesys.unprotectedAddDatanode(nodeImage.getDatanodeDescriptor());
+      // We don't need to add these descriptors any more.
     }
   }
 

src/java/org/apache/hadoop/dfs/FSNamesystem.java

@@ -1557,15 +1557,7 @@ class FSNamesystem implements FSConstants {
    * 
    * @see DataNode#register()
    */
-  public void registerDatanode(DatanodeRegistration nodeReg,
-                                            String networkLocation
-                                            ) throws IOException {
-    registerDatanodeInternal(nodeReg, networkLocation);
-    getEditLog().logSync();
-  }
-
-  private synchronized void registerDatanodeInternal(
-                                            DatanodeRegistration nodeReg,
+  public synchronized void registerDatanode(DatanodeRegistration nodeReg,
                                             String networkLocation
                                             ) throws IOException {
 
@@ -1604,8 +1596,6 @@ class FSNamesystem implements FSConstants {
       removeDatanode(nodeN);
       // physically remove node from datanodeMap
       wipeDatanode(nodeN);
-      // and log removal
-      getEditLog().logRemoveDatanode(nodeN);
       nodeN = null;
     }
 
@@ -1618,13 +1608,19 @@ class FSNamesystem implements FSConstants {
                                       + "node restarted.");
       } else {
         // nodeS is found
-        // The registering datanode is a replacement node for the existing 
-        // data storage, which from now on will be served by a new node.
-        NameNode.stateChangeLog.debug(
-                                      "BLOCK* NameSystem.registerDatanode: "
+        /* The registering datanode is a replacement node for the existing 
+          data storage, which from now on will be served by a new node.
+          If this message repeats, both nodes might have same storageID 
+          by (insanely rare) random chance. User needs to restart one of the
+          nodes with its data cleared (or user can just remove the StorageID
+          value in "VERSION" file under the data directory of the datanode,
+          but this is might not work if VERSION file format has changed 
+       */        
+        NameNode.stateChangeLog.info( "BLOCK* NameSystem.registerDatanode: "
                                       + "node " + nodeS.getName()
-                                      + " is replaced by " + nodeReg.getName() + ".");
-        getEditLog().logRemoveDatanode(nodeS);
+                                      + " is replaced by " + nodeReg.getName() + 
+                                      " with the same storageID " +
+                                      nodeReg.getStorageID());
       }
       // update cluster map
       clusterMap.remove(nodeS);
@@ -1632,9 +1628,6 @@ class FSNamesystem implements FSConstants {
       nodeS.setNetworkLocation(networkLocation);
       clusterMap.add(nodeS);
       nodeS.setHostName(hostName);
-      if ( nodeS != nodeN ) {
-        getEditLog().logAddDatanode( nodeS );
-      }
         
       // also treat the registration message as a heartbeat
       synchronized(heartbeats) {
@@ -1662,7 +1655,6 @@ class FSNamesystem implements FSConstants {
       = new DatanodeDescriptor(nodeReg, networkLocation, hostName);
     unprotectedAddDatanode(nodeDescr);
     clusterMap.add(nodeDescr);
-    getEditLog().logAddDatanode(nodeDescr);
       
     // also treat the registration message as a heartbeat
     synchronized(heartbeats) {