use of org.openkilda.wfm.topology.flow.ComponentType in project open-kilda by telstra.
the class CrudBolt method execute.
/**
* {@inheritDoc}
*/
@Override
public void execute(Tuple tuple) {
if (CtrlAction.boltHandlerEntrance(this, tuple))
return;
logger.trace("Flow Cache before: {}", flowCache);
ComponentType componentId = ComponentType.valueOf(tuple.getSourceComponent());
StreamType streamId = StreamType.valueOf(tuple.getSourceStreamId());
String flowId = tuple.getStringByField(Utils.FLOW_ID);
String correlationId = Utils.DEFAULT_CORRELATION_ID;
try {
logger.debug("Request tuple={}", tuple);
switch(componentId) {
case SPLITTER_BOLT:
Message msg = (Message) tuple.getValueByField(AbstractTopology.MESSAGE_FIELD);
correlationId = msg.getCorrelationId();
CommandMessage cmsg = (msg instanceof CommandMessage) ? (CommandMessage) msg : null;
InfoMessage imsg = (msg instanceof InfoMessage) ? (InfoMessage) msg : null;
logger.info("Flow request: {}={}, {}={}, component={}, stream={}", Utils.CORRELATION_ID, correlationId, Utils.FLOW_ID, flowId, componentId, streamId);
switch(streamId) {
case CREATE:
handleCreateRequest(cmsg, tuple);
break;
case UPDATE:
handleUpdateRequest(cmsg, tuple);
break;
case DELETE:
handleDeleteRequest(flowId, cmsg, tuple);
break;
case PUSH:
handlePushRequest(flowId, imsg, tuple);
break;
case UNPUSH:
handleUnpushRequest(flowId, imsg, tuple);
break;
case PATH:
handlePathRequest(flowId, cmsg, tuple);
break;
case RESTORE:
handleRestoreRequest(cmsg, tuple);
break;
case REROUTE:
handleRerouteRequest(cmsg, tuple);
break;
case STATUS:
handleStatusRequest(flowId, cmsg, tuple);
break;
case CACHE_SYNC:
handleCacheSyncRequest(cmsg, tuple);
break;
case READ:
if (flowId != null) {
handleReadRequest(flowId, cmsg, tuple);
} else {
handleDumpRequest(cmsg, tuple);
}
break;
default:
logger.debug("Unexpected stream: component={}, stream={}", componentId, streamId);
break;
}
break;
case SPEAKER_BOLT:
case TRANSACTION_BOLT:
FlowState newStatus = (FlowState) tuple.getValueByField(FlowTopology.STATUS_FIELD);
logger.info("Flow {} status {}: component={}, stream={}", flowId, newStatus, componentId, streamId);
switch(streamId) {
case STATUS:
handleStateRequest(flowId, newStatus, tuple);
break;
default:
logger.debug("Unexpected stream: component={}, stream={}", componentId, streamId);
break;
}
break;
case TOPOLOGY_ENGINE_BOLT:
ErrorMessage errorMessage = (ErrorMessage) tuple.getValueByField(AbstractTopology.MESSAGE_FIELD);
logger.info("Flow {} error: component={}, stream={}", flowId, componentId, streamId);
switch(streamId) {
case STATUS:
handleErrorRequest(flowId, errorMessage, tuple);
break;
default:
logger.debug("Unexpected stream: component={}, stream={}", componentId, streamId);
break;
}
break;
default:
logger.debug("Unexpected component: {}", componentId);
break;
}
} catch (CacheException exception) {
String logMessage = format("%s: %s", exception.getErrorMessage(), exception.getErrorDescription());
logger.error("{}, {}={}, {}={}, component={}, stream={}", logMessage, Utils.CORRELATION_ID, correlationId, Utils.FLOW_ID, flowId, componentId, streamId, exception);
ErrorMessage errorMessage = buildErrorMessage(correlationId, exception.getErrorType(), logMessage, componentId.toString().toLowerCase());
Values error = new Values(errorMessage, exception.getErrorType());
outputCollector.emit(StreamType.ERROR.toString(), tuple, error);
} catch (IOException exception) {
logger.error("Could not deserialize message {}", tuple, exception);
} finally {
logger.debug("Command message ack: component={}, stream={}, tuple={}", tuple.getSourceComponent(), tuple.getSourceStreamId(), tuple);
outputCollector.ack(tuple);
}
logger.trace("Flow Cache after: {}", flowCache);
}
use of org.openkilda.wfm.topology.flow.ComponentType in project open-kilda by telstra.
the class NorthboundReplyBolt method execute.
/**
* {@inheritDoc}
*/
@Override
public void execute(Tuple tuple) {
ComponentType componentId = ComponentType.valueOf(tuple.getSourceComponent());
StreamType streamId = StreamType.valueOf(tuple.getSourceStreamId());
Message message = (Message) tuple.getValueByField(AbstractTopology.MESSAGE_FIELD);
Values values = null;
try {
logger.debug("Request tuple={}", tuple);
switch(componentId) {
case TOPOLOGY_ENGINE_BOLT:
case CRUD_BOLT:
case ERROR_BOLT:
logger.debug("Flow response: {}={}, component={}, stream={}, message={}", Utils.CORRELATION_ID, message.getCorrelationId(), componentId, streamId, message);
message.setDestination(Destination.NORTHBOUND);
values = new Values(MAPPER.writeValueAsString(message));
outputCollector.emit(StreamType.RESPONSE.toString(), tuple, values);
break;
default:
logger.debug("Flow unknown response: {}={}, component={}, stream={}, message={}", Utils.CORRELATION_ID, message.getCorrelationId(), componentId, streamId, message);
break;
}
} catch (JsonProcessingException exception) {
logger.error("Could not serialize message: component={}, stream={}, message={}", componentId, streamId, message);
} finally {
logger.debug("Northbound-Reply message ack: component={}, stream={}, tuple={}, values={}", tuple.getSourceComponent(), tuple.getSourceStreamId(), tuple, values);
outputCollector.ack(tuple);
}
}
use of org.openkilda.wfm.topology.flow.ComponentType in project open-kilda by telstra.
the class ErrorBolt method execute.
/**
* {@inheritDoc}
*/
@Override
public void execute(Tuple tuple) {
ComponentType componentId = ComponentType.valueOf(tuple.getSourceComponent());
StreamType streamId = StreamType.valueOf(tuple.getSourceStreamId());
ErrorType errorType = (ErrorType) tuple.getValueByField(FlowTopology.ERROR_TYPE_FIELD);
ErrorMessage error = (ErrorMessage) tuple.getValueByField(AbstractTopology.MESSAGE_FIELD);
error.setDestination(Destination.NORTHBOUND);
Values values = new Values(error);
try {
logger.debug("Request tuple={}", tuple);
switch(componentId) {
case CRUD_BOLT:
case SPLITTER_BOLT:
logger.debug("Error message: data={}", error.getData());
outputCollector.emit(StreamType.RESPONSE.toString(), tuple, values);
break;
default:
logger.debug("Skip message from unknown component: component={}, stream={}, error-type={}", componentId, streamId, errorType);
break;
}
} catch (Exception exception) {
logger.error("Could not process message: {}", tuple, exception);
} finally {
logger.debug("Error message ack: component={}, stream={}, tuple={}, values={}", tuple.getSourceComponent(), tuple.getSourceStreamId(), tuple, values);
outputCollector.ack(tuple);
}
}
use of org.openkilda.wfm.topology.flow.ComponentType in project open-kilda by telstra.
the class TransactionBolt method execute.
@Override
public void execute(Tuple tuple) {
if (CtrlAction.boltHandlerEntrance(this, tuple))
return;
logger.trace("States before: {}", transactions);
ComponentType componentId = ComponentType.valueOf(tuple.getSourceComponent());
StreamType streamId = StreamType.valueOf(tuple.getSourceStreamId());
Long transactionId = (Long) tuple.getValueByField(Utils.TRANSACTION_ID);
String switchId = (String) tuple.getValueByField(FlowTopology.SWITCH_ID_FIELD);
String flowId = (String) tuple.getValueByField(Utils.FLOW_ID);
Object message = tuple.getValueByField(FlowTopology.MESSAGE_FIELD);
Map<String, Set<Long>> flowTransactions;
Set<Long> flowTransactionIds;
Values values = null;
try {
logger.debug("Request tuple={}", tuple);
switch(componentId) {
case TOPOLOGY_ENGINE_BOLT:
logger.info("Transaction from TopologyEngine: switch-id={}, {}={}, {}={}", switchId, Utils.FLOW_ID, flowId, Utils.TRANSACTION_ID, transactionId);
flowTransactions = transactions.get(switchId);
if (flowTransactions == null) {
flowTransactions = new ConcurrentHashMap<>();
transactions.put(switchId, flowTransactions);
}
flowTransactionIds = flowTransactions.get(flowId);
if (flowTransactionIds == null) {
flowTransactionIds = new ConcurrentHashSet<>();
flowTransactions.put(flowId, flowTransactionIds);
}
if (!flowTransactionIds.add(transactionId)) {
throw new RuntimeException(String.format("Transaction adding failure: id %d already exists", transactionId));
}
logger.info("Set status {}: switch-id={}, {}={}, {}={}", FlowState.IN_PROGRESS, switchId, Utils.FLOW_ID, flowId, Utils.TRANSACTION_ID, transactionId);
values = new Values(flowId, FlowState.IN_PROGRESS);
outputCollector.emit(StreamType.STATUS.toString(), tuple, values);
values = new Values(message);
outputCollector.emit(streamId.toString(), tuple, values);
break;
case SPEAKER_BOLT:
logger.info("Transaction from Speaker: switch-id={}, {}={}, {}={}", switchId, Utils.FLOW_ID, flowId, Utils.TRANSACTION_ID, transactionId);
flowTransactions = transactions.get(switchId);
if (flowTransactions != null) {
flowTransactionIds = flowTransactions.get(flowId);
if (flowTransactionIds != null) {
if (flowTransactionIds.remove(transactionId)) {
if (flowTransactionIds.isEmpty()) {
//
// All transactions have been removed .. the Flow
// can now be considered "UP"
//
logger.info("Set status {}: switch-id={}, {}={}, {}={}", FlowState.UP, switchId, Utils.FLOW_ID, flowId, Utils.TRANSACTION_ID, transactionId);
values = new Values(flowId, FlowState.UP);
outputCollector.emit(StreamType.STATUS.toString(), tuple, values);
flowTransactions.remove(flowId);
} else {
logger.debug("Transaction {} not empty yet, count = {}", transactionId, flowTransactionIds.size());
}
} else {
logger.warn("Transaction removing: transaction id not found");
}
} else {
logger.warn("Transaction removing failure: flow id not found");
}
if (flowTransactions.isEmpty()) {
transactions.delete(switchId);
}
} else {
logger.warn("Transaction removing failure: switch id not found");
}
break;
default:
logger.debug("Skip undefined message: message={}", tuple);
break;
}
} catch (RuntimeException exception) {
logger.error("Set status {}: switch-id={}, {}={}, {}={}", FlowState.DOWN, switchId, Utils.FLOW_ID, flowId, Utils.TRANSACTION_ID, transactionId, exception);
values = new Values(flowId, FlowState.DOWN);
outputCollector.emit(StreamType.STATUS.toString(), tuple, values);
} finally {
logger.debug("Transaction message ack: component={}, stream={}, tuple={}, values={}", tuple.getSourceComponent(), tuple.getSourceStreamId(), tuple, values);
outputCollector.ack(tuple);
}
logger.trace("States after: {}", transactions);
}
Aggregations