Rebase and update fix

ashishkr200 · ashishkr200 · commit c874233b0694 · 2026-04-20T12:42:32.000+05:30
diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/ContainerManagerImpl.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/ContainerManagerImpl.java
@@ -252,7 +252,7 @@ private ContainerInfo createContainer(Pipeline pipeline, String owner)
   private ContainerInfo allocateContainer(final Pipeline pipeline,
                                           final String owner)
       throws IOException {
-    if (!pipelineManager.hasEnoughSpace(pipeline, maxContainerSize)) {
+    if (!pipelineManager.hasEnoughSpace(pipeline)) {
       LOG.debug("Cannot allocate a new container because pipeline {} does not have the required space {}.",
           pipeline, maxContainerSize);
       return null;
@@ -287,8 +287,6 @@ private ContainerInfo allocateContainer(final Pipeline pipeline,
     scmContainerManagerMetrics.incNumSuccessfulCreateContainers();
     // Record pending allocation - tracks containers scheduled but not yet written
     pendingContainerTracker.recordPendingAllocation(pipeline, containerID);
-    LOG.debug("Allocated container {} on pipeline {}. Recorded as pending on {} DataNodes",
-        containerID, pipeline.getId(), pipeline.getNodes().size());
 
     return containerStateManager.getContainer(containerID);
   }
diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/DeadNodeHandler.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/DeadNodeHandler.java
@@ -97,10 +97,6 @@ public void onMessage(final DatanodeDetails datanodeDetails,
        * action.
        */
       LOG.info("A dead datanode is detected. {}", datanodeDetails);
-      PendingContainerTracker pending = nodeManager.getPendingContainerTracker();
-      if (pending != null) {
-        pending.clearPendingForDatanode(datanodeDetails);
-      }
       closeContainers(datanodeDetails, publisher);
       destroyPipelines(datanodeDetails);
 
diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/NodeManager.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/NodeManager.java
@@ -432,5 +432,5 @@ default void removeNode(DatanodeDetails datanodeDetails) throws NodeNotFoundExce
    * True if the node can accept another container of the given size, accounting for
    * {@link #getPendingContainerTracker()}.
    */
-  boolean hasSpaceForNewContainerAllocation(DatanodeDetails node, long containerSize);
+  boolean hasSpaceForNewContainerAllocation(DatanodeDetails node);
 }
diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/SCMNodeManager.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/SCMNodeManager.java
@@ -251,19 +251,16 @@ public PendingContainerTracker getPendingContainerTracker() {
    * SCM pending allocations.
    */
   @Override
-  public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node,
-      long containerSize) {
-    if (node == null) {
-      return false;
-    }
+  public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node) {
+    Objects.requireNonNull(node, "node==null");
     try {
       DatanodeInfo datanodeInfo = getDatanodeInfo(node);
       if (datanodeInfo == null) {
         LOG.warn("DatanodeInfo not found for node {}", node.getUuidString());
         return false;
       }
       return pendingContainerTracker.hasEffectiveAllocatableSpaceForNewContainer(
-          node, datanodeInfo, containerSize);
+          node, datanodeInfo);
     } catch (Exception e) {
       LOG.warn("Error checking allocatable space for node {}", node.getUuidString(), e);
       return false;
@@ -1145,8 +1142,6 @@ private SCMNodeStat getNodeStatInternal(DatanodeDetails datanodeDetails) {
         freeSpaceToSpare += reportProto.getFreeSpaceToSpare();
         reserved += reportProto.getReserved();
       }
-      // SCM-side pending container allocations (not yet in DN reports) count toward committed.
-      committed += pendingContainerTracker.getPendingAllocationSize(datanodeDetails);
       return new SCMNodeStat(capacity, used, remaining, committed,
           freeSpaceToSpare, reserved);
     } catch (NodeNotFoundException e) {
diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/SCMNodeMetrics.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/SCMNodeMetrics.java
@@ -137,6 +137,14 @@ void incNumPendingContainersRemoved() {
     numPendingContainersRemoved.incr();
   }
 
+  public long getNumPendingContainersAdded() {
+    return numPendingContainersAdded.value();
+  }
+
+  public long getNumPendingContainersRemoved() {
+    return numPendingContainersRemoved.value();
+  }
+
   void incNumSkippedFullNodeContainerAllocation() {
     numSkippedFullNodeContainerAllocation.incr();
   }
diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/StaleNodeHandler.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/StaleNodeHandler.java
@@ -46,10 +46,6 @@ public StaleNodeHandler(NodeManager nodeManager,
   @Override
   public void onMessage(DatanodeDetails datanodeDetails,
       EventPublisher publisher) {
-    PendingContainerTracker pending = nodeManager.getPendingContainerTracker();
-    if (pending != null) {
-      pending.clearPendingForDatanode(datanodeDetails);
-    }
     Set<PipelineID> pipelineIds =
         nodeManager.getPipelines(datanodeDetails);
     LOG.info("Datanode {} moved to stale state. Finalizing its pipelines {}",
diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/pipeline/PipelineManager.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/pipeline/PipelineManager.java
@@ -213,13 +213,12 @@ void reinitialize(Table<PipelineID, Pipeline> pipelineStore)
   void releaseWriteLock();
 
   /**
-   * Checks whether all Datanodes in the specified pipeline have greater than the specified space, containerSize.
+   * Checks whether all Datanodes in the specified pipeline have greater than the container size.
    * @param pipeline pipeline to check
-   * @param containerSize the required amount of space
-   * @return false if all the volumes on any Datanode in the pipeline have space less than equal to the specified
+   * @return false if all the volumes on any Datanode in the pipeline have space less than equal to the
    * containerSize, otherwise true
    */
-  boolean hasEnoughSpace(Pipeline pipeline, long containerSize);
+  boolean hasEnoughSpace(Pipeline pipeline);
 
   int openContainerLimit(List<DatanodeDetails> datanodes);
 
diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/pipeline/PipelineManagerImpl.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/pipeline/PipelineManagerImpl.java
@@ -634,9 +634,9 @@ private boolean isOpenWithUnregisteredNodes(Pipeline pipeline) {
   }
 
   @Override
-  public boolean hasEnoughSpace(Pipeline pipeline, long containerSize) {
+  public boolean hasEnoughSpace(Pipeline pipeline) {
     for (DatanodeDetails node : pipeline.getNodes()) {
-      if (!nodeManager.hasSpaceForNewContainerAllocation(node, containerSize)) {
+      if (!nodeManager.hasSpaceForNewContainerAllocation(node)) {
         return false;
       }
     }
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/MockNodeManager.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/MockNodeManager.java
@@ -945,20 +945,21 @@ public void setNumHealthyVolumes(int value) {
 
   @Override
   public PendingContainerTracker getPendingContainerTracker() {
+    int rollIntervalMs = 5 * 60 * 1000;
     if (pendingContainerTracker == null) {
-      pendingContainerTracker = new PendingContainerTracker(5L * 1024 * 1024 * 1024);
+      pendingContainerTracker = new PendingContainerTracker(5L * 1024 * 1024 * 1024, rollIntervalMs, null);
     }
     return pendingContainerTracker;
   }
 
   @Override
-  public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node, long containerSize) {
+  public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node) {
     DatanodeInfo info = getDatanodeInfo(node);
     if (info == null) {
       return false;
     }
     return getPendingContainerTracker()
-        .hasEffectiveAllocatableSpaceForNewContainer(node, info, containerSize);
+        .hasEffectiveAllocatableSpaceForNewContainer(node, info);
   }
 
   /**
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/SimpleMockNodeManager.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/SimpleMockNodeManager.java
@@ -439,14 +439,15 @@ public Boolean isNodeRegistered(DatanodeDetails datanodeDetails) {
 
   @Override
   public PendingContainerTracker getPendingContainerTracker() {
+    int rollIntervalMs = 5 * 60 * 1000;
     if (pendingContainerTracker == null) {
-      pendingContainerTracker = new PendingContainerTracker(5L * 1024 * 1024 * 1024);
+      pendingContainerTracker = new PendingContainerTracker(5L * 1024 * 1024 * 1024, rollIntervalMs, null);
     }
     return pendingContainerTracker;
   }
 
   @Override
-  public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node, long containerSize) {
+  public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node) {
     return true;
   }
 
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/TestContainerManagerImpl.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/TestContainerManagerImpl.java
@@ -26,7 +26,6 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
@@ -104,7 +103,7 @@ void setUp() throws Exception {
     pipelineManager = spy(base);
 
     // Default: allow allocation in tests unless a test overrides it.
-    doReturn(true).when(pipelineManager).hasEnoughSpace(any(Pipeline.class), anyLong());
+    doReturn(true).when(pipelineManager).hasEnoughSpace(any(Pipeline.class));
 
     pipelineManager.createPipeline(RatisReplicationConfig.getInstance(
         ReplicationFactor.THREE));
@@ -143,7 +142,7 @@ void testAllocateContainer() throws Exception {
    */
   @Test
   public void testGetMatchingContainerReturnsNullWhenNotEnoughSpaceInDatanodes() throws IOException {
-    doReturn(false).when(pipelineManager).hasEnoughSpace(any(), anyLong());
+    doReturn(false).when(pipelineManager).hasEnoughSpace(any());
 
     long sizeRequired = 256 * 1024 * 1024; // 256 MB
     Pipeline pipeline = pipelineManager.getPipelines().iterator().next();
@@ -168,7 +167,7 @@ public void testGetMatchingContainerReturnsContainerWhenEnoughSpaceInDatanodes()
     // create a spy to mock hasEnoughSpace to always return true
     PipelineManager spyPipelineManager = spy(pipelineManager);
     doReturn(true).when(spyPipelineManager)
-        .hasEnoughSpace(any(Pipeline.class), anyLong());
+        .hasEnoughSpace(any(Pipeline.class));
 
     // create a new ContainerManager using the spy
     File tempDir = new File(testDir, "tempDir");
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestContainerPlacement.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestContainerPlacement.java
@@ -26,7 +26,6 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
@@ -161,7 +160,7 @@ SCMNodeManager createNodeManager(OzoneConfiguration config) {
   ContainerManager createContainerManager()
       throws IOException {
     pipelineManager = spy(pipelineManager);
-    doReturn(true).when(pipelineManager).hasEnoughSpace(any(), anyLong());
+    doReturn(true).when(pipelineManager).hasEnoughSpace(any());
 
     return new ContainerManagerImpl(conf,
         scmhaManager, sequenceIdGen, pipelineManager,
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/pipeline/MockPipelineManager.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/pipeline/MockPipelineManager.java
@@ -334,9 +334,9 @@ public boolean isPipelineCreationFrozen() {
   }
 
   @Override
-  public boolean hasEnoughSpace(Pipeline pipeline, long containerSize) {
+  public boolean hasEnoughSpace(Pipeline pipeline) {
     for (DatanodeDetails node : pipeline.getNodes()) {
-      if (!nodeManager.hasSpaceForNewContainerAllocation(node, containerSize)) {
+      if (!nodeManager.hasSpaceForNewContainerAllocation(node)) {
         return false;
       }
     }
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/pipeline/TestPipelineManagerImpl.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/pipeline/TestPipelineManagerImpl.java
@@ -938,7 +938,7 @@ public void testCreatePipelineForRead() throws IOException {
   }
 
   /**
-   * {@link PipelineManager#hasEnoughSpace(Pipeline, long)} should return false if all the
+   * {@link PipelineManager#hasEnoughSpace(Pipeline)} should return false if all the
    * volumes on any Datanode in the pipeline have less than equal to the space required for creating a new container.
    */
   @Test
@@ -979,11 +979,10 @@ public void testHasEnoughSpace() throws IOException {
     }
     doAnswer(invocation -> {
       DatanodeDetails dn = invocation.getArgument(0);
-      long cs = invocation.getArgument(1);
       DatanodeInfo info = mockedNodeManager.getDatanodeInfo(dn);
-      return SCMCommonPlacementPolicy.hasEnoughSpace(info, 0, cs);
-    }).when(mockedNodeManager).hasSpaceForNewContainerAllocation(any(DatanodeDetails.class), anyLong());
-    assertTrue(pipelineManager.hasEnoughSpace(pipeline, containerSize));
+      return SCMCommonPlacementPolicy.hasEnoughSpace(info, 0, containerSize);
+    }).when(mockedNodeManager).hasSpaceForNewContainerAllocation(any(DatanodeDetails.class));
+    assertTrue(pipelineManager.hasEnoughSpace(pipeline));
 
     // Case 2: One node does not have enough space.
     /*
@@ -997,13 +996,13 @@ public void testHasEnoughSpace() throws IOException {
     DatanodeInfo datanodeInfo = datanodeInfoList.get(0);
     datanodeInfo.updateStorageReports(HddsTestUtils.createStorageReports(datanodeInfo.getID(), 200L, 120L,
         20L));
-    assertFalse(pipelineManager.hasEnoughSpace(pipeline, containerSize));
+    assertFalse(pipelineManager.hasEnoughSpace(pipeline));
 
     // Case 3: All nodes do not have enough space.
     for (DatanodeInfo info : datanodeInfoList) {
       info.updateStorageReports(HddsTestUtils.createStorageReports(info.getID(), 200L, 100L, 20L));
     }
-    assertFalse(pipelineManager.hasEnoughSpace(pipeline, containerSize));
+    assertFalse(pipelineManager.hasEnoughSpace(pipeline));
   }
 
   private Set<ContainerReplica> createContainerReplicasList(
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/container/TestPendingContainerTrackerIntegration.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/container/TestPendingContainerTrackerIntegration.java
@@ -20,11 +20,11 @@
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Set;
 import org.apache.hadoop.hdds.HddsConfigKeys;
 import org.apache.hadoop.hdds.client.RatisReplicationConfig;
 import org.apache.hadoop.hdds.conf.OzoneConfiguration;
@@ -135,13 +135,12 @@ public void testKeyWriteRecordsPendingAndICRRemovesIt() throws Exception {
     // Verify pending containers are tracked for all nodes in pipeline
     List<DatanodeDetails> nodesWithPending = new ArrayList<>();
     for (DatanodeDetails dn : pipeline.getNodes()) {
-      long pendingSize = pendingTracker.getPendingAllocationSize(dn);
-      if (pendingSize > 0) {
+      long pendingCount = pendingTracker.getPendingContainerCount(dn);
+      if (pendingCount > 0) {
         nodesWithPending.add(dn);
-        LOG.info("DataNode {} has {} bytes pending", dn.getUuidString(), pendingSize);
+        LOG.info("DataNode {} has {} pending containers", dn.getUuidString(), pendingCount);
 
-        Set<ContainerID> pendingContainers = pendingTracker.getPendingContainers(dn);
-        assertThat(pendingContainers).contains(container.containerID());
+        assertThat(pendingTracker.containsPendingContainer(dn, container.containerID()));
       }
     }
 
@@ -155,7 +154,7 @@ public void testKeyWriteRecordsPendingAndICRRemovesIt() throws Exception {
 
     // Write a key
     String keyName = "testKey1";
-    byte[] data = "Hello Ozone - Testing Pending Container Tracker".getBytes(UTF_8);
+    byte[] data = "Testing Pending Container Tracker".getBytes(UTF_8);
 
     LOG.info("Writing key: {}", keyName);
     try (OzoneOutputStream out = bucket.createKey(keyName, data.length,
@@ -168,8 +167,7 @@ public void testKeyWriteRecordsPendingAndICRRemovesIt() throws Exception {
     // Wait for ICRs to be sent
     GenericTestUtils.waitFor(() -> {
       for (DatanodeDetails dn : nodesWithPending) {
-        Set<ContainerID> pendingContainers = pendingTracker.getPendingContainers(dn);
-        if (pendingContainers.contains(container.containerID())) {
+        if (pendingTracker.containsPendingContainer(dn, container.containerID())) {
           LOG.info("Still waiting for ICR from DN {}", dn.getUuidString());
           return false;
         }
@@ -181,8 +179,7 @@ public void testKeyWriteRecordsPendingAndICRRemovesIt() throws Exception {
 
     // Verify all pending containers removed
     for (DatanodeDetails dn : nodesWithPending) {
-      Set<ContainerID> pendingContainers = pendingTracker.getPendingContainers(dn);
-      assertThat(pendingContainers).doesNotContain(container.containerID());
+      assertFalse(pendingTracker.containsPendingContainer(dn, container.containerID()));
     }
 
     // Verify remove metrics increased
@@ -207,20 +204,16 @@ public void testIdempotentPendingTracking() throws Exception {
     DatanodeDetails firstNode = pipeline.getFirstNode();
     
     // Record initial state
-    long initialSize = pendingTracker.getPendingAllocationSize(firstNode);
-    int initialCount = pendingTracker.getPendingContainers(firstNode).size();
-    
-    LOG.info("Initial pending state: size={}, count={}", initialSize, initialCount);
-    
+    long initialCount = pendingTracker.getPendingContainerCount(firstNode);
+
+    LOG.info("Initial pending state: count={}", initialCount);
+
     // Try adding the same container again (simulates retry or duplicate allocation)
     pendingTracker.recordPendingAllocationForDatanode(firstNode, container.containerID());
-    
-    long afterSize = pendingTracker.getPendingAllocationSize(firstNode);
-    int afterCount = pendingTracker.getPendingContainers(firstNode).size();
-    
-    // Size and count should remain the same (idempotent)
-    assertEquals(initialSize, afterSize,
-        "Pending size should not change when adding duplicate container");
+
+    long afterCount = pendingTracker.getPendingContainerCount(firstNode);
+
+    // Count should remain the same (idempotent)
     assertEquals(initialCount, afterCount,
         "Pending count should not change when adding duplicate container");
 

Original file line number	Diff line number	Diff line change
`@@ -432,5 +432,5 @@ default void removeNode(DatanodeDetails datanodeDetails) throws NodeNotFoundExce`
`432`	`432`	`* True if the node can accept another container of the given size, accounting for`
`433`	`433`	`* {@link #getPendingContainerTracker()}.`
`434`	`434`	`*/`
`435`		`- boolean hasSpaceForNewContainerAllocation(DatanodeDetails node, long containerSize);`
	`435`	`+ boolean hasSpaceForNewContainerAllocation(DatanodeDetails node);`
`436`	`436`	`}`
Original file line number	Diff line number	Diff line change
`@@ -137,6 +137,14 @@ void incNumPendingContainersRemoved() {`
`137`	`137`	`numPendingContainersRemoved.incr();`
`138`	`138`	`}`
`139`	`139`
	`140`	`+ public long getNumPendingContainersAdded() {`
	`141`	`+ return numPendingContainersAdded.value();`
	`142`	`+ }`
	`143`	`+`
	`144`	`+ public long getNumPendingContainersRemoved() {`
	`145`	`+ return numPendingContainersRemoved.value();`
	`146`	`+ }`
	`147`	`+`
`140`	`148`	`void incNumSkippedFullNodeContainerAllocation() {`
`141`	`149`	`numSkippedFullNodeContainerAllocation.incr();`
`142`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -634,9 +634,9 @@ private boolean isOpenWithUnregisteredNodes(Pipeline pipeline) {`
`634`	`634`	`}`
`635`	`635`
`636`	`636`	`@Override`
`637`		`- public boolean hasEnoughSpace(Pipeline pipeline, long containerSize) {`
	`637`	`+ public boolean hasEnoughSpace(Pipeline pipeline) {`
`638`	`638`	`for (DatanodeDetails node : pipeline.getNodes()) {`
`639`		`- if (!nodeManager.hasSpaceForNewContainerAllocation(node, containerSize)) {`
	`639`	`+ if (!nodeManager.hasSpaceForNewContainerAllocation(node)) {`
`640`	`640`	`return false;`
`641`	`641`	`}`
`642`	`642`	`}`
Original file line number	Diff line number	Diff line change
`@@ -945,20 +945,21 @@ public void setNumHealthyVolumes(int value) {`
`945`	`945`
`946`	`946`	`@Override`
`947`	`947`	`public PendingContainerTracker getPendingContainerTracker() {`
	`948`	`+ int rollIntervalMs = 5 * 60 * 1000;`
`948`	`949`	`if (pendingContainerTracker == null) {`
`949`		`- pendingContainerTracker = new PendingContainerTracker(5L * 1024 * 1024 * 1024);`
	`950`	`+ pendingContainerTracker = new PendingContainerTracker(5L * 1024 * 1024 * 1024, rollIntervalMs, null);`
`950`	`951`	`}`
`951`	`952`	`return pendingContainerTracker;`
`952`	`953`	`}`
`953`	`954`
`954`	`955`	`@Override`
`955`		`- public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node, long containerSize) {`
	`956`	`+ public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node) {`
`956`	`957`	`DatanodeInfo info = getDatanodeInfo(node);`
`957`	`958`	`if (info == null) {`
`958`	`959`	`return false;`
`959`	`960`	`}`
`960`	`961`	`return getPendingContainerTracker()`
`961`		`- .hasEffectiveAllocatableSpaceForNewContainer(node, info, containerSize);`
	`962`	`+ .hasEffectiveAllocatableSpaceForNewContainer(node, info);`
`962`	`963`	`}`
`963`	`964`
`964`	`965`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -439,14 +439,15 @@ public Boolean isNodeRegistered(DatanodeDetails datanodeDetails) {`
`439`	`439`
`440`	`440`	`@Override`
`441`	`441`	`public PendingContainerTracker getPendingContainerTracker() {`
	`442`	`+ int rollIntervalMs = 5 * 60 * 1000;`
`442`	`443`	`if (pendingContainerTracker == null) {`
`443`		`- pendingContainerTracker = new PendingContainerTracker(5L * 1024 * 1024 * 1024);`
	`444`	`+ pendingContainerTracker = new PendingContainerTracker(5L * 1024 * 1024 * 1024, rollIntervalMs, null);`
`444`	`445`	`}`
`445`	`446`	`return pendingContainerTracker;`
`446`	`447`	`}`
`447`	`448`
`448`	`449`	`@Override`
`449`		`- public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node, long containerSize) {`
	`450`	`+ public boolean hasSpaceForNewContainerAllocation(DatanodeDetails node) {`
`450`	`451`	`return true;`
`451`	`452`	`}`
`452`	`453`