Report that the given datanode has cleared the primary.
It is fully aware of the failover, and it has sent the
incremental block report.

@param node
the datanode that has reported
420505
protected void reportPrimaryCleared(DatanodeID node) {
    if (node != null && shouldUpdateNodes()) {
      if (outStandingReports.remove(node)) {
        LOG.info("Failover: Outstanding reports: " + outStandingReports.size());
      }
    }
  }
996356
def setCurrentNode(self, node):
        
        self.blockSignals(True)
        self.clearSelection()
        if node:
            node.setSelected(True)
        self.blockSignals(False)
12965
private void handleLeaveEvent(Node node) {
    SwimMember member = members.get(MemberId.from(node.id().id()));
    if (member != null && !member.isActive()) {
      members.remove(member.id());
    }
  }
836398
protected void nodeCompleted(Object parent, Object node) {
        getProxyBuilder().getCurrentFactory().onNodeCompleted(getProxyBuilder().getChildBuilder(), parent, node);
    }
304176
public void remove(int node) {
        if (node == NIL) {
            throw new IllegalArgumentException();
        }
        if (left(node) != NIL && right(node) != NIL) {
            // inner node
            final int next = next(node);
            assert next != NIL;
            swap(node, next);
        }
        assert left(node) == NIL || right(node) == NIL;

        final int parent = parent(node);
        int child = left(node);
        if (child == NIL) {
            child = right(node);
        }

        if (child == NIL) {
            // no children
            if (node == root) {
                assert size() == 1 : size();
                root = NIL;
            } else {
                if (node == left(parent)) {
                    left(parent, NIL);
                } else {
                    assert node == right(parent);
                    right(parent, NIL);
                }
            }
        } else {
            // one single child
            if (node == root) {
                assert size() == 2;
                root = child;
            } else if (node == left(parent)) {
                left(parent, child);
            } else {
                assert node == right(parent);
                right(parent, child);
            }
            parent(child, parent);
        }

        release(node);
        rebalance(parent);
    }
857855
public void lockNode(final NodeId node) {
		Lockable<SharedBufferNode> sharedBufferNode = sharedBuffer.getEntry(node);
		if (sharedBufferNode != null) {
			sharedBufferNode.lock();
			sharedBuffer.upsertEntry(node, sharedBufferNode);
		}
	}
415150
public void nodeFeedback(String nodeName, List<ResourceType> resourceTypes,
      NodeUsageReport usageReport) {
    List<FaultStatsForType> faultStats = nodeToFaultStats.get(nodeName);
    if (faultStats == null) {
      LOG.info("Received node feedback for deleted node " + nodeName);
      return;
    }
    boolean statsModified = false;
    synchronized (faultStats) {
      if (tooManyFailedConnectionsInSession(usageReport)) {
        for (FaultStatsForType stat : faultStats) {
          if (resourceTypes.contains(stat.type)) {
            stat.numSessionsWithFailedConnections++;
            statsModified = true;
          }
        }
      }
      if (tooManyFailuresInSession(usageReport)) {
        for (FaultStatsForType stat : faultStats) {
          if (resourceTypes.contains(stat.type)) {
            stat.numSessionsWithTooManyFailures++;
            statsModified = true;
          }
        }
      }
    }

    if (statsModified) {
      blacklistIfNeeded(nodeName, faultStats);
    }
  }
825031
@Override
  public boolean deleteDataNode(String nodeId) {
    try {
      rwLock.writeLock().lock();
      return this.dataNodeMap.containsKey(nodeId) && deleteDataNode(this.dataNodeMap.get(nodeId));
    } finally {
      rwLock.writeLock().unlock();
    }
  }
134325
public void disconnect(Node<T> o, Node<T> t) {
    if (!o.equals(t)) {
      o.disconnectFrom(t);
      t.disconnectFrom(o);
    }
  }
727646
public void removeNode(ClusterNode node) {
    String host = node.getHost();
    NodeContainer container = hostToRunnableNode.get(host);
    if (container != null) {
      if (container.removeNode(node)) {
        runnableNodeCount--;
      }
      if (container.isEmpty()) {
        hostToRunnableNode.remove(host);
      }
    }
    Node rack = topologyCache.getNode(host).getParent();
    container = rackToRunnableNode.get(rack);
    if (container != null) {
      container.removeNode(node);
      if (container.isEmpty()) {
        rackToRunnableNode.remove(rack);
      }
    }
  }
65328
public void onNodeFailed(final IExecutionNode node, final Throwable cause) {

        final Description description = descriptionMap.get(Long.valueOf(node.getId()));
        notifyTestFailed(description, cause);

    }
1269200
public void nodeSelected(SiteNode node) {
		if (node != null) {
			siteModel.setSelectedItem(ScanPanel.cleanSiteName(node, true));
		}
	}
808773
public void blocksBeingWrittenReport(DatanodeRegistration nodeReg,
      BlockReport blocks) throws IOException {
    verifyRequest(nodeReg);
    long[] blocksAsLong = blocks.getBlockReportInLongs();
    BlockListAsLongs blist = new BlockListAsLongs(blocksAsLong);
    boolean processed = namesystem.processBlocksBeingWrittenReport(nodeReg, blist);

    String message = "*BLOCK* NameNode.blocksBeingWrittenReport: "
        +"from "+nodeReg.getName()+" "+blist.getNumberOfBlocks() +" blocks";
    if (!processed) {
      message += " was discarded.";
    }
    stateChangeLog.info(message);
  }
315946
public void deleteNodeIndex(EntityMetadata entityMetadata, GraphDatabaseService graphDb, Node node)
    {
        if (!isNodeAutoIndexingEnabled(graphDb) && entityMetadata.isIndexable())
        {
            Index<Node> nodeIndex = graphDb.index().forNodes(entityMetadata.getIndexName());
            nodeIndex.remove(node);
        }
    }
1362483
private boolean shouldRemoveNode(HistoryNode node) {
    if (node == null) {
      return true;
    }
    
    int sizeOfChildren = 0;
    if (node.children != null) {
      sizeOfChildren = node.children.size();
    }
    
    if (sizeOfChildren > 0) {
      return false;
    }
    
    int sizeOfNotifications = 0;
    if (node.notifications != null) {
      for (List<HistoryTreeEntry> notiList : node.notifications.values()) {
        if (notiList != null) {
          sizeOfNotifications += notiList.size();
          if (sizeOfNotifications > 0) {
            return false;
          }
        }
      }
    }
    
    return true;
  }
1270478
@CacheEntryRemoved
   @SuppressWarnings("unused")
   public void nodeRemoved(CacheEntryRemovedEvent event) {
      if ( event.isPre() ) {
         return;
      }
      localCache.remove( event.getKey() );
   }
672000
private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
    }