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

Example 31 with FlowRequest

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

the class UpdateRequestAction method sendUpdateCommand.

private void sendUpdateCommand(Flow flow, RequestedFlow targetFlow, String anotherFlowId, FlowSwapEndpointsFsm stateMachine) {
    FlowRequest flowRequest = RequestedFlowMapper.INSTANCE.toFlowRequest(flow);
    flowRequest.setSource(new FlowEndpoint(targetFlow.getSrcSwitch(), targetFlow.getSrcPort(), targetFlow.getSrcVlan()));
    flowRequest.setDestination(new FlowEndpoint(targetFlow.getDestSwitch(), targetFlow.getDestPort(), targetFlow.getDestVlan()));
    if (flow.getLoopSwitchId() != null) {
        boolean flowLoopedOnSrc = flow.getLoopSwitchId().equals(flow.getSrcSwitchId());
        flowRequest.setLoopSwitchId(flowLoopedOnSrc ? flowRequest.getSource().getSwitchId() : flowRequest.getDestination().getSwitchId());
    }
    flowRequest.setBulkUpdateFlowIds(Sets.newHashSet(anotherFlowId));
    flowRequest.setType(Type.UPDATE);
    stateMachine.sendFlowUpdateRequest(flowRequest);
    stateMachine.saveFlowActionToHistory(flow.getFlowId(), "Command for update flow has been sent");
}

Example 32 with FlowRequest

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

the class FlowOperationsService method updateFlow.

/**
 * Partial update flow.
 */
public Flow updateFlow(FlowOperationsCarrier carrier, FlowPatch flowPatch) throws FlowNotFoundException {
    String flowId = flowPatch.getFlowId();
    if (yFlowRepository.isSubFlow(flowId)) {
        throw new MessageException(ErrorType.REQUEST_INVALID, "Could not modify flow", format("%s is a sub-flow of a y-flow. Operations on sub-flows are forbidden.", flowId));
    }
    UpdateFlowResult updateFlowResult = transactionManager.doInTransaction(() -> {
        Optional<Flow> foundFlow = flowRepository.findById(flowId);
        if (!foundFlow.isPresent()) {
            return Optional.<UpdateFlowResult>empty();
        }
        Flow currentFlow = foundFlow.get();
        validateFlow(flowPatch, currentFlow);
        final UpdateFlowResult.UpdateFlowResultBuilder result = prepareFlowUpdateResult(flowPatch, currentFlow);
        Optional.ofNullable(flowPatch.getMaxLatency()).ifPresent(currentFlow::setMaxLatency);
        Optional.ofNullable(flowPatch.getMaxLatencyTier2()).ifPresent(currentFlow::setMaxLatencyTier2);
        Optional.ofNullable(flowPatch.getPriority()).ifPresent(currentFlow::setPriority);
        Optional.ofNullable(flowPatch.getPinned()).ifPresent(currentFlow::setPinned);
        Optional.ofNullable(flowPatch.getDescription()).ifPresent(currentFlow::setDescription);
        Optional.ofNullable(flowPatch.getTargetPathComputationStrategy()).ifPresent(currentFlow::setTargetPathComputationStrategy);
        Optional.ofNullable(flowPatch.getStrictBandwidth()).ifPresent(currentFlow::setStrictBandwidth);
        Optional.ofNullable(flowPatch.getPeriodicPings()).ifPresent(periodicPings -> {
            boolean oldPeriodicPings = currentFlow.isPeriodicPings();
            currentFlow.setPeriodicPings(periodicPings);
            if (oldPeriodicPings != currentFlow.isPeriodicPings()) {
                carrier.emitPeriodicPingUpdate(flowId, flowPatch.getPeriodicPings());
            }
        });
        return Optional.of(result.updatedFlow(currentFlow).build());
    }).orElseThrow(() -> new FlowNotFoundException(flowId));
    Flow updatedFlow = updateFlowResult.getUpdatedFlow();
    if (updateFlowResult.isNeedUpdateFlow()) {
        FlowRequest flowRequest = RequestedFlowMapper.INSTANCE.toFlowRequest(updatedFlow);
        addChangedFields(flowRequest, flowPatch);
        flowDashboardLogger.onFlowPatchUpdate(RequestedFlowMapper.INSTANCE.toFlow(flowRequest));
        carrier.sendUpdateRequest(addChangedFields(flowRequest, flowPatch));
    } else {
        flowDashboardLogger.onFlowPatchUpdate(updatedFlow);
        carrier.sendNorthboundResponse(buildFlowResponse(updatedFlow));
    }
    return updateFlowResult.getUpdatedFlow();
}

Example 33 with FlowRequest

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

the class RequestedFlowMapperTest method mapFlowToFlowRequestTest.

@Test
public void mapFlowToFlowRequestTest() {
    FlowRequest flowRequest = RequestedFlowMapper.INSTANCE.toFlowRequest(FLOW);
    assertEquals(FLOW_ID, flowRequest.getFlowId());
    assertEquals(SRC_SWITCH_ID, flowRequest.getSource().getSwitchId());
    assertEquals(SRC_PORT, flowRequest.getSource().getPortNumber());
    assertEquals(SRC_VLAN, flowRequest.getSource().getOuterVlanId());
    assertEquals(SRC_INNER_VLAN, flowRequest.getSource().getInnerVlanId());
    assertEquals(DST_SWITCH_ID, flowRequest.getDestination().getSwitchId());
    assertEquals(DST_PORT, flowRequest.getDestination().getPortNumber());
    assertEquals(DST_VLAN, flowRequest.getDestination().getOuterVlanId());
    assertEquals(DST_INNER_VLAN, flowRequest.getDestination().getInnerVlanId());
    assertEquals(PRIORITY, flowRequest.getPriority());
    assertEquals(DESCRIPTION, flowRequest.getDescription());
    assertEquals(BANDWIDTH, flowRequest.getBandwidth());
    assertEquals(MAX_LATENCY, flowRequest.getMaxLatency());
    assertEquals(MAX_LATENCY_TIER_2, flowRequest.getMaxLatencyTier2());
    assertEquals(org.openkilda.messaging.payload.flow.FlowEncapsulationType.TRANSIT_VLAN, flowRequest.getEncapsulationType());
    assertEquals(PATH_COMPUTATION_STRATEGY, flowRequest.getPathComputationStrategy());
    assertEquals(LOOP_SWITCH_ID, flowRequest.getLoopSwitchId());
    assertTrue(flowRequest.isPinned());
    assertTrue(flowRequest.isAllocateProtectedPath());
    assertTrue(flowRequest.isIgnoreBandwidth());
    assertTrue(flowRequest.isPeriodicPings());
    assertEquals(new DetectConnectedDevicesDto(true, true, true, true, true, true, true, true), flowRequest.getDetectConnectedDevices());
}

Example 34 with FlowRequest

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

the class RequestedFlowMapper method toFlowRequest.

/**
 * Convert {@link Flow} to {@link FlowRequest}.
 */
public FlowRequest toFlowRequest(Flow flow) {
    FlowRequest request = generatedMap(flow);
    request.setSource(new FlowSourceAdapter(flow).getEndpoint());
    request.setDestination(new FlowDestAdapter(flow).getEndpoint());
    return request;
}

Example 35 with FlowRequest

use of org.openkilda.messaging.command.flow.FlowRequest 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);
        }
    }
}