Examples with State org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.ContainerReplicaProto.State used on opensource projects

Example 1 with State

use of org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.ContainerReplicaProto.State in project ozone by apache.

the class TestReconContainerManager method testCheckAndAddNewContainerBatch.

@Test
public void testCheckAndAddNewContainerBatch() throws IOException {
    List<ContainerReplicaProto> containerReplicaProtoList = new LinkedList<>();
    ReconContainerManager containerManager = getContainerManager();
    State[] stateTypes = State.values();
    LifeCycleState[] lifeCycleStateTypes = LifeCycleState.values();
    int lifeCycleStateCount = lifeCycleStateTypes.length;
    for (int i = 200; i < 300; i++) {
        assertFalse(containerManager.containerExist(ContainerID.valueOf(i)));
        ContainerReplicaProto.Builder ciBuilder = ContainerReplicaProto.newBuilder();
        ContainerReplicaProto crp = ciBuilder.setContainerID(i).setState(stateTypes[i % lifeCycleStateCount]).build();
        containerReplicaProtoList.add(crp);
    }
    containerManager.checkAndAddNewContainerBatch(containerReplicaProtoList);
    for (long i = 200L; i < 300L; i++) {
        assertTrue(containerManager.containerExist(ContainerID.valueOf(i)));
    }
    // Doing it one more time should not change any state.
    containerManager.checkAndAddNewContainerBatch(containerReplicaProtoList);
    for (int i = 200; i < 300; i++) {
        assertTrue(containerManager.containerExist(ContainerID.valueOf(i)));
        assertEquals(lifeCycleStateTypes[i % lifeCycleStateCount], getContainerManager().getContainer(ContainerID.valueOf(i)).getState());
    }
}

Example 2 with State

use of org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.ContainerReplicaProto.State in project ozone by apache.

the class TestReconIncrementalContainerReportHandler method testProcessICRStateMismatch.

@Test
public void testProcessICRStateMismatch() throws IOException {
    // Recon container state is "OPEN".
    // Replica state could be any Non OPEN state.
    long containerId = 11;
    for (State state : Arrays.asList(State.CLOSING, State.QUASI_CLOSED, State.CLOSED)) {
        ContainerWithPipeline containerWithPipeline = getTestContainer(containerId++, OPEN);
        ContainerID containerID = containerWithPipeline.getContainerInfo().containerID();
        ReconContainerManager containerManager = getContainerManager();
        containerManager.addNewContainer(containerWithPipeline);
        DatanodeDetails datanodeDetails = containerWithPipeline.getPipeline().getFirstNode();
        NodeManager nodeManagerMock = mock(NodeManager.class);
        when(nodeManagerMock.getNodeByUuid(any())).thenReturn(datanodeDetails);
        IncrementalContainerReportFromDatanode reportMock = mock(IncrementalContainerReportFromDatanode.class);
        when(reportMock.getDatanodeDetails()).thenReturn(containerWithPipeline.getPipeline().getFirstNode());
        IncrementalContainerReportProto containerReport = getIncrementalContainerReportProto(containerID, state, datanodeDetails.getUuidString());
        when(reportMock.getReport()).thenReturn(containerReport);
        ReconIncrementalContainerReportHandler reconIcr = new ReconIncrementalContainerReportHandler(nodeManagerMock, containerManager, SCMContext.emptyContext());
        reconIcr.onMessage(reportMock, mock(EventPublisher.class));
        assertTrue(containerManager.containerExist(containerID));
        assertEquals(1, containerManager.getContainerReplicas(containerID).size());
        LifeCycleState expectedState = getContainerStateFromReplicaState(state);
        LifeCycleState actualState = containerManager.getContainer(containerID).getState();
        assertEquals(String.format("Expecting %s in " + "container state for replica state %s", expectedState, state), expectedState, actualState);
    }
}

Example 3 with State

use of org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.ContainerReplicaProto.State 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);
    }
}

Example 4 with State

use of org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.ContainerReplicaProto.State in project ozone by apache.

the class ReplicationManager method handleUnstableContainer.

/**
 * Handles unstable container.
 * A container is inconsistent if any of the replica state doesn't
 * match the container state. We have to take appropriate action
 * based on state of the replica.
 *
 * @param container ContainerInfo
 * @param replicas Set of ContainerReplicas
 */
private void handleUnstableContainer(final ContainerInfo container, final Set<ContainerReplica> replicas) {
    // Find unhealthy replicas
    List<ContainerReplica> unhealthyReplicas = replicas.stream().filter(r -> !compareState(container.getState(), r.getState())).collect(Collectors.toList());
    Iterator<ContainerReplica> iterator = unhealthyReplicas.iterator();
    while (iterator.hasNext()) {
        final ContainerReplica replica = iterator.next();
        final State state = replica.getState();
        if (state == State.OPEN || state == State.CLOSING) {
            sendCloseCommand(container, replica.getDatanodeDetails(), false);
            iterator.remove();
        }
        if (state == State.QUASI_CLOSED) {
            // Send force close command if the BCSID matches
            if (container.getSequenceId() == replica.getSequenceId()) {
                sendCloseCommand(container, replica.getDatanodeDetails(), true);
                iterator.remove();
            }
        }
    }
    // Now we are left with the replicas which are either unhealthy or
    // the BCSID doesn't match. These replicas should be deleted.
    /*
     * If we have unhealthy replicas we go under replicated and then
     * replicate the healthy copy.
     *
     * We also make sure that we delete only one unhealthy replica at a time.
     *
     * If there are two unhealthy replica:
     *  - Delete first unhealthy replica
     *  - Re-replicate the healthy copy
     *  - Delete second unhealthy replica
     *  - Re-replicate the healthy copy
     *
     * Note: Only one action will be executed in a single ReplicationMonitor
     *       iteration. So to complete all the above actions we need four
     *       ReplicationMonitor iterations.
     */
    unhealthyReplicas.stream().findFirst().ifPresent(replica -> sendDeleteCommand(container, replica.getDatanodeDetails(), false));
}