Examples with FlowValidationRequest org.openkilda.messaging.command.flow.FlowValidationRequest used on opensource projects

Example 1 with FlowValidationRequest

use of org.openkilda.messaging.command.flow.FlowValidationRequest in project open-kilda by telstra.

the class FlowValidationHubServiceTest method testMainPath.

@Test
public void testMainPath() throws DuplicateKeyException, UnknownKeyException {
    FlowValidationHubCarrier carrier = new FlowValidationHubCarrier() {

        @Override
        public void sendSpeakerRequest(String flowId, CommandData commandData) {
            assertTrue(commandData instanceof DumpRulesForFlowHsRequest || commandData instanceof DumpMetersForFlowHsRequest || commandData instanceof DumpGroupsForFlowHsRequest);
            List<SwitchId> switchIds = Lists.newArrayList(TEST_SWITCH_ID_A, TEST_SWITCH_ID_B, TEST_SWITCH_ID_C, TEST_SWITCH_ID_E);
            if (commandData instanceof DumpRulesForFlowHsRequest) {
                assertTrue(switchIds.contains(((DumpRulesForFlowHsRequest) commandData).getSwitchId()));
            } else if (commandData instanceof DumpMetersForFlowHsRequest) {
                assertTrue(switchIds.contains(((DumpMetersForFlowHsRequest) commandData).getSwitchId()));
            } else {
                assertTrue(switchIds.contains(((DumpGroupsForFlowHsRequest) commandData).getSwitchId()));
            }
        }

        @Override
        public void sendNorthboundResponse(List<? extends InfoData> message) {
            assertEquals(4, message.size());
            try {
                assertEquals(flowValidationService.validateFlow(TEST_FLOW_ID_A, getSwitchFlowEntriesWithTransitVlan(), getSwitchMeterEntries(), getSwitchGroupEntries()), message);
            } catch (FlowNotFoundException | SwitchNotFoundException e) {
            // tested in the FlowValidationServiceTest
            }
        }

        @Override
        public void sendNorthboundResponse(Message message) {
            fail();
        }

        @Override
        public void cancelTimeoutCallback(String key) {
            assertEquals(TEST_KEY, key);
        }

        @Override
        public void sendInactive() {
        }
    };
    flowValidationHubService = new FlowValidationHubService(carrier, persistenceManager, flowResourcesManager, MIN_BURST_SIZE_IN_KBITS, BURST_COEFFICIENT);
    buildTransitVlanFlow("");
    flowValidationHubService.handleFlowValidationRequest(TEST_KEY, new CommandContext(), new FlowValidationRequest(TEST_FLOW_ID_A));
    for (SwitchFlowEntries switchFlowEntries : getSwitchFlowEntriesWithTransitVlan()) {
        flowValidationHubService.handleAsyncResponse(TEST_KEY, switchFlowEntries);
    }
    for (SwitchMeterEntries switchMeterEntries : getSwitchMeterEntries()) {
        flowValidationHubService.handleAsyncResponse(TEST_KEY, switchMeterEntries);
    }
    for (SwitchGroupEntries switchGroupEntries : getSwitchGroupEntries()) {
        flowValidationHubService.handleAsyncResponse(TEST_KEY, switchGroupEntries);
    }
}

Example 2 with FlowValidationRequest

use of org.openkilda.messaging.command.flow.FlowValidationRequest in project open-kilda by telstra.

the class FlowServiceImpl method validateFlow.

/**
 * {@inheritDoc}
 */
@Override
public CompletableFuture<List<FlowValidationDto>> validateFlow(final String flowId) {
    logger.debug("Validate flow request for flow {}", flowId);
    CommandMessage message = new CommandMessage(new FlowValidationRequest(flowId), System.currentTimeMillis(), RequestCorrelationId.getId());
    return messagingChannel.sendAndGetChunked(flowHsTopic, message).thenApply(response -> response.stream().map(FlowValidationResponse.class::cast).map(flowMapper::toFlowValidationDto).collect(Collectors.toList()));
}

Example 3 with FlowValidationRequest

use of org.openkilda.messaging.command.flow.FlowValidationRequest in project open-kilda by telstra.

the class RouterBolt method handleInput.

@Override
protected void handleInput(Tuple input) {
    if (active) {
        String key = input.getStringByField(FIELD_ID_KEY);
        if (StringUtils.isBlank(key)) {
            // TODO: the key must be unique, but the correlationId comes in from outside and we can't guarantee that.
            // IMPORTANT: Storm may initiate reprocessing of the same tuple (e.g. in the case of timeout) and
            // cause creating multiple FSMs for the same tuple. This must be avoided.
            // As for now tuples are routed by the key field, and services can check FSM uniqueness.
            key = getCommandContext().getCorrelationId();
        }
        CommandMessage message = (CommandMessage) input.getValueByField(FIELD_ID_PAYLOAD);
        MessageData data = message.getData();
        if (data instanceof FlowRequest) {
            FlowRequest request = (FlowRequest) data;
            log.debug("Received request {} with key {}", request, key);
            Values values = new Values(key, request.getFlowId(), request);
            switch(request.getType()) {
                case CREATE:
                    emitWithContext(ROUTER_TO_FLOW_CREATE_HUB.name(), input, values);
                    break;
                case UPDATE:
                    emitWithContext(ROUTER_TO_FLOW_UPDATE_HUB.name(), input, values);
                    break;
                default:
                    throw new UnsupportedOperationException(format("Flow operation %s is not supported", request.getType()));
            }
        } else if (data instanceof FlowRerouteRequest) {
            FlowRerouteRequest rerouteRequest = (FlowRerouteRequest) data;
            log.debug("Received a reroute request {}/{} with key {}. MessageId {}", rerouteRequest.getFlowId(), rerouteRequest.getAffectedIsl(), key, input.getMessageId());
            Values values = new Values(key, rerouteRequest.getFlowId(), data);
            emitWithContext(ROUTER_TO_FLOW_REROUTE_HUB.name(), input, values);
        } else if (data instanceof FlowDeleteRequest) {
            FlowDeleteRequest deleteRequest = (FlowDeleteRequest) data;
            log.debug("Received a delete request {} with key {}. MessageId {}", deleteRequest.getFlowId(), key, input.getMessageId());
            Values values = new Values(key, deleteRequest.getFlowId(), data);
            emitWithContext(ROUTER_TO_FLOW_DELETE_HUB.name(), input, values);
        } else if (data instanceof FlowPathSwapRequest) {
            FlowPathSwapRequest pathSwapRequest = (FlowPathSwapRequest) data;
            log.debug("Received a path swap request {} with key {}. MessageId {}", pathSwapRequest.getFlowId(), key, input.getMessageId());
            Values values = new Values(key, pathSwapRequest.getFlowId(), data);
            emitWithContext(ROUTER_TO_FLOW_PATH_SWAP_HUB.name(), input, values);
        } else if (data instanceof SwapFlowEndpointRequest) {
            log.debug("Received a swap flow endpoints request with key {}. MessageId {}", key, input.getMessageId());
            emitWithContext(ROUTER_TO_FLOW_SWAP_ENDPOINTS_HUB.name(), input, new Values(key, data));
        } else if (data instanceof CreateFlowLoopRequest) {
            log.debug("Received a create flow loop request with key {}. MessageId {}", key, input.getMessageId());
            CreateFlowLoopRequest request = (CreateFlowLoopRequest) data;
            emitWithContext(ROUTER_TO_FLOW_UPDATE_HUB.name(), input, new Values(key, request.getFlowId(), data));
        } else if (data instanceof DeleteFlowLoopRequest) {
            log.debug("Received a delete flow loop request with key {}. MessageId {}", key, input.getMessageId());
            DeleteFlowLoopRequest request = (DeleteFlowLoopRequest) data;
            emitWithContext(ROUTER_TO_FLOW_UPDATE_HUB.name(), input, new Values(key, request.getFlowId(), data));
        } else if (data instanceof FlowMirrorPointCreateRequest) {
            log.debug("Received a flow mirror point create request with key {}. MessageId {}", key, input.getMessageId());
            FlowMirrorPointCreateRequest request = (FlowMirrorPointCreateRequest) data;
            emitWithContext(ROUTER_TO_FLOW_CREATE_MIRROR_POINT_HUB.name(), input, new Values(key, request.getFlowId(), data));
        } else if (data instanceof FlowMirrorPointDeleteRequest) {
            log.debug("Received a flow mirror point delete request with key {}. MessageId {}", key, input.getMessageId());
            FlowMirrorPointDeleteRequest request = (FlowMirrorPointDeleteRequest) data;
            emitWithContext(ROUTER_TO_FLOW_DELETE_MIRROR_POINT_HUB.name(), input, new Values(key, request.getFlowId(), data));
        } else if (data instanceof FlowValidationRequest) {
            log.debug("Received a flow validation request with key {}. MessageId {}", key, input.getMessageId());
            FlowValidationRequest request = (FlowValidationRequest) data;
            emitWithContext(ROUTER_TO_FLOW_VALIDATION_HUB.name(), input, new Values(key, request.getFlowId(), data));
        } else if (data instanceof YFlowRequest) {
            YFlowRequest request = (YFlowRequest) data;
            log.debug("Received request {} with key {}", request, key);
            Values values = new Values(key, request.getYFlowId(), request);
            switch(request.getType()) {
                case CREATE:
                    emitWithContext(ROUTER_TO_YFLOW_CREATE_HUB.name(), input, values);
                    break;
                case UPDATE:
                    emitWithContext(ROUTER_TO_YFLOW_UPDATE_HUB.name(), input, values);
                    break;
                default:
                    throw new UnsupportedOperationException(format("Y-flow operation %s is not supported", request.getType()));
            }
        } else if (data instanceof YFlowPartialUpdateRequest) {
            YFlowPartialUpdateRequest request = (YFlowPartialUpdateRequest) data;
            log.debug("Received a y-flow partial update request {} with key {}", request, key);
            emitWithContext(ROUTER_TO_YFLOW_UPDATE_HUB.name(), input, new Values(key, request.getYFlowId(), data));
        } else if (data instanceof YFlowRerouteRequest) {
            YFlowRerouteRequest request = (YFlowRerouteRequest) data;
            log.debug("Received a y-flow reroute request {} with key {}", data, key);
            emitWithContext(ROUTER_TO_YFLOW_REROUTE_HUB.name(), input, new Values(key, request.getYFlowId(), data));
        } else if (data instanceof YFlowDeleteRequest) {
            YFlowDeleteRequest request = (YFlowDeleteRequest) data;
            log.debug("Received a y-flow delete request {} with key {}", request, key);
            emitWithContext(ROUTER_TO_YFLOW_DELETE_HUB.name(), input, new Values(key, request.getYFlowId(), data));
        } else if (data instanceof YFlowsDumpRequest) {
            log.debug("Received a y-flow dump request {} with key {}", data, key);
            emitWithContext(ROUTER_TO_YFLOW_READ.name(), input, new Values(key, data));
        } else if (data instanceof YFlowReadRequest) {
            log.debug("Received a y-flow read request {} with key {}", data, key);
            emitWithContext(ROUTER_TO_YFLOW_READ.name(), input, new Values(key, data));
        } else if (data instanceof YFlowPathsReadRequest) {
            log.debug("Received a y-flow read path request {} with key {}", data, key);
            emitWithContext(ROUTER_TO_YFLOW_READ.name(), input, new Values(key, data));
        } else if (data instanceof SubFlowsReadRequest) {
            log.debug("Received a y-flow sub-flows request {} with key {}", data, key);
            emitWithContext(ROUTER_TO_YFLOW_READ.name(), input, new Values(key, data));
        } else if (data instanceof YFlowValidationRequest) {
            YFlowValidationRequest request = (YFlowValidationRequest) data;
            log.debug("Received a y-flow validation request {} with key {}", request, key);
            emitWithContext(ROUTER_TO_YFLOW_VALIDATION_HUB.name(), input, new Values(key, request.getYFlowId(), data));
        } else if (data instanceof YFlowSyncRequest) {
            YFlowSyncRequest request = (YFlowSyncRequest) data;
            log.debug("Received a y-flow synchronization request {} with key {}", request, key);
            YFlowRerouteRequest rerouteRequest = new YFlowRerouteRequest(request.getYFlowId(), emptySet(), true, "initiated via synchronization request", false);
            emitWithContext(ROUTER_TO_YFLOW_REROUTE_HUB.name(), input, new Values(key, rerouteRequest.getYFlowId(), rerouteRequest));
        } else {
            unhandledInput(input);
        }
    }
}

Example 4 with FlowValidationRequest

use of org.openkilda.messaging.command.flow.FlowValidationRequest in project open-kilda by telstra.

the class FlowValidationHubBolt method onRequest.

@Override
protected void onRequest(Tuple input) throws PipelineException {
    currentKey = pullKey(input);
    FlowValidationRequest payload = pullValue(input, FIELD_ID_PAYLOAD, FlowValidationRequest.class);
    try {
        service.handleFlowValidationRequest(currentKey, getCommandContext(), payload);
    } catch (DuplicateKeyException e) {
        log.error("Failed to handle a request with key {}. {}", currentKey, e.getMessage());
    }
}

Example 5 with FlowValidationRequest

use of org.openkilda.messaging.command.flow.FlowValidationRequest in project open-kilda by telstra.

the class FlowValidationHubServiceTest method testTimeout.

@Test
public void testTimeout() throws DuplicateKeyException, UnknownKeyException {
    FlowValidationHubCarrier carrier = new FlowValidationHubCarrier() {

        @Override
        public void sendSpeakerRequest(String flowId, CommandData commandData) {
            assertTrue(commandData instanceof DumpRulesForFlowHsRequest || commandData instanceof DumpMetersForFlowHsRequest || commandData instanceof DumpGroupsForFlowHsRequest);
            List<SwitchId> switchIds = Lists.newArrayList(TEST_SWITCH_ID_A, TEST_SWITCH_ID_B, TEST_SWITCH_ID_C, TEST_SWITCH_ID_E);
            if (commandData instanceof DumpRulesForFlowHsRequest) {
                assertTrue(switchIds.contains(((DumpRulesForFlowHsRequest) commandData).getSwitchId()));
            } else if (commandData instanceof DumpMetersForFlowHsRequest) {
                assertTrue(switchIds.contains(((DumpMetersForFlowHsRequest) commandData).getSwitchId()));
            } else {
                assertTrue(switchIds.contains(((DumpGroupsForFlowHsRequest) commandData).getSwitchId()));
            }
        }

        @Override
        public void sendNorthboundResponse(List<? extends InfoData> message) {
            fail();
        }

        @Override
        public void sendNorthboundResponse(Message message) {
            assertEquals(ErrorType.OPERATION_TIMED_OUT, ((ErrorMessage) message).getData().getErrorType());
        }

        @Override
        public void cancelTimeoutCallback(String key) {
            assertEquals(TEST_KEY, key);
        }

        @Override
        public void sendInactive() {
        }
    };
    flowValidationHubService = new FlowValidationHubService(carrier, persistenceManager, flowResourcesManager, MIN_BURST_SIZE_IN_KBITS, BURST_COEFFICIENT);
    buildTransitVlanFlow("");
    flowValidationHubService.handleFlowValidationRequest(TEST_KEY, new CommandContext(), new FlowValidationRequest(TEST_FLOW_ID_A));
    flowValidationHubService.handleTimeout(TEST_KEY);
}