Examples with SCM org.apache.hadoop.hdds.conf.ConfigTag.SCM used on opensource projects

Example 1 with SCM

use of org.apache.hadoop.hdds.conf.ConfigTag.SCM in project ozone by apache.

the class ReplicationManager method processContainer.

/**
 * Process the given container.
 *
 * @param container ContainerInfo
 */
@SuppressWarnings("checkstyle:methodlength")
private void processContainer(ContainerInfo container, ReplicationManagerReport report) {
    if (!shouldRun()) {
        return;
    }
    final ContainerID id = container.containerID();
    try {
        // race conditions with ICR/FCR handlers
        synchronized (container) {
            final Set<ContainerReplica> replicas = containerManager.getContainerReplicas(id);
            final LifeCycleState state = container.getState();
            report.increment(state);
            /*
         * We don't take any action if the container is in OPEN state and
         * the container is healthy. If the container is not healthy, i.e.
         * the replicas are not in OPEN state, send CLOSE_CONTAINER command.
         */
            if (state == LifeCycleState.OPEN) {
                if (!isOpenContainerHealthy(container, replicas)) {
                    report.incrementAndSample(HealthState.OPEN_UNHEALTHY, container.containerID());
                    eventPublisher.fireEvent(SCMEvents.CLOSE_CONTAINER, id);
                }
                return;
            }
            /*
         * If the container is in CLOSING state, the replicas can either
         * be in OPEN or in CLOSING state. In both of this cases
         * we have to resend close container command to the datanodes.
         */
            if (state == LifeCycleState.CLOSING) {
                for (ContainerReplica replica : replicas) {
                    if (replica.getState() != State.UNHEALTHY) {
                        sendCloseCommand(container, replica.getDatanodeDetails(), false);
                    }
                }
                return;
            }
            /*
         * If the container is in QUASI_CLOSED state, check and close the
         * container if possible.
         */
            if (state == LifeCycleState.QUASI_CLOSED) {
                if (canForceCloseContainer(container, replicas)) {
                    forceCloseContainer(container, replicas);
                    return;
                } else {
                    report.incrementAndSample(HealthState.QUASI_CLOSED_STUCK, container.containerID());
                }
            }
            /*
         * Before processing the container we have to reconcile the
         * inflightReplication and inflightDeletion actions.
         *
         * We remove the entry from inflightReplication and inflightDeletion
         * list, if the operation is completed or if it has timed out.
         */
            updateInflightAction(container, inflightReplication, action -> replicas.stream().anyMatch(r -> r.getDatanodeDetails().equals(action.datanode)), () -> metrics.incrNumReplicationCmdsTimeout(), action -> updateCompletedReplicationMetrics(container, action));
            updateInflightAction(container, inflightDeletion, action -> replicas.stream().noneMatch(r -> r.getDatanodeDetails().equals(action.datanode)), () -> metrics.incrNumDeletionCmdsTimeout(), action -> updateCompletedDeletionMetrics(container, action));
            /*
         * If container is under deleting and all it's replicas are deleted,
         * then make the container as CLEANED,
         * or resend the delete replica command if needed.
         */
            if (state == LifeCycleState.DELETING) {
                handleContainerUnderDelete(container, replicas);
                return;
            }
            /**
             * We don't need to take any action for a DELETE container - eventually
             * it will be removed from SCM.
             */
            if (state == LifeCycleState.DELETED) {
                return;
            }
            ContainerReplicaCount replicaSet = getContainerReplicaCount(container, replicas);
            ContainerPlacementStatus placementStatus = getPlacementStatus(replicas, container.getReplicationConfig().getRequiredNodes());
            /*
         * We don't have to take any action if the container is healthy.
         *
         * According to ReplicationMonitor container is considered healthy if
         * the container is either in QUASI_CLOSED or in CLOSED state and has
         * exact number of replicas in the same state.
         */
            if (isContainerEmpty(container, replicas)) {
                report.incrementAndSample(HealthState.EMPTY, container.containerID());
                /*
           *  If container is empty, schedule task to delete the container.
           */
                deleteContainerReplicas(container, replicas);
                return;
            }
            /*
         * Check if the container is under replicated and take appropriate
         * action.
         */
            boolean sufficientlyReplicated = replicaSet.isSufficientlyReplicated();
            boolean placementSatisfied = placementStatus.isPolicySatisfied();
            if (!sufficientlyReplicated || !placementSatisfied) {
                if (!sufficientlyReplicated) {
                    report.incrementAndSample(HealthState.UNDER_REPLICATED, container.containerID());
                    if (replicaSet.isMissing()) {
                        report.incrementAndSample(HealthState.MISSING, container.containerID());
                    }
                }
                if (!placementSatisfied) {
                    report.incrementAndSample(HealthState.MIS_REPLICATED, container.containerID());
                }
                handleUnderReplicatedContainer(container, replicaSet, placementStatus);
                return;
            }
            /*
         * Check if the container is over replicated and take appropriate
         * action.
         */
            if (replicaSet.isOverReplicated()) {
                report.incrementAndSample(HealthState.OVER_REPLICATED, container.containerID());
                handleOverReplicatedContainer(container, replicaSet);
                return;
            }
            /*
       If we get here, the container is not over replicated or under replicated
       but it may be "unhealthy", which means it has one or more replica which
       are not in the same state as the container itself.
       */
            if (!replicaSet.isHealthy()) {
                report.incrementAndSample(HealthState.UNHEALTHY, container.containerID());
                handleUnstableContainer(container, replicas);
            }
        }
    } catch (ContainerNotFoundException ex) {
        LOG.warn("Missing container {}.", id);
    } catch (Exception ex) {
        LOG.warn("Process container {} error: ", id, ex);
    }
}