/** * Create a MD-SAL flow ID to be associated with a flow entry in a * VTN data flow. * * @param id A VTN flow ID. * @param index An index value that specifies a flow entry in a VTN * data flow. * @return A MD-SAL flow ID. */ public static FlowId createMdFlowId(BigInteger id, Integer index) { return new FlowId(ID_PREFIX + id + ID_SEPARATOR + index); }
/** * Add a MD-SAL flow entry to be removed from the flow table. * * @param flow A MD-SAL flow entry to be removed from the flow table. */ public void addRemoved(Flow flow) { removedIds.add(flow.getId().getValue()); }
public TableFlowUpdateState(final KeyedInstanceIdentifier<Table, TableKey> tablePath, final Table table) { tableRef = tablePath; tableKey = tablePath.getKey(); flowIdByHash = HashBiMap.create(); if(table != null) { final FlowHashIdMapping flowHashMapping = table.getAugmentation(FlowHashIdMapping.class); if (flowHashMapping != null) { final List<FlowHashIdMap> flowHashMap = flowHashMapping.getFlowHashIdMap() != null ? flowHashMapping.getFlowHashIdMap() : Collections.<FlowHashIdMap> emptyList(); for (final FlowHashIdMap flowHashId : flowHashMap) { try { flowIdByHash.put(flowHashId.getKey(), flowHashId.getFlowId()); } catch (final Exception e) { //flowHashId.getKey() too verbose for standard log. if(LOG.isDebugEnabled()) { final FlowId currData = flowIdByHash.get(flowHashId.getKey()); LOG.debug("flow hashing hit a duplicate for {} -> {}. Curr value: {} Equals:{}. Exception was raised:", flowHashId.getKey(), flowHashId.getFlowId(), currData, flowHashId.getFlowId().equals(currData), e); } else { LOG.warn("flow hashing hit a duplicate {}. Exception was raised: {}. Enable DEBUG for more detail.", flowHashId.getFlowId().toString().substring(0, Math.min(TRUNCATED_LOG_MESSAGE_LENGTH,flowHashId.getFlowId().toString().length())), e.getMessage().substring(0,Math.min(TRUNCATED_LOG_MESSAGE_LENGTH,e.getMessage().length()))); } } } } } }
FlowKey key = new FlowKey(new FlowId(id)); flowBuilder.setKey(key); flowBuilder.setId(new FlowId(id)); Flow flowToSend = flowBuilder.build(); builder.setFlowRef(new FlowRef(flowPath)); builder.setFlowTable(new FlowTableRef(tableInstanceId)); builder.setTransactionUri(new Uri(flowToSend.getId().getValue()));
FlowId id = vdf.getSalFlowId(); FlowId mdId = flow.getId(); if (mdId.equals(id)) { ctx.log(LOG, VTNLogLevel.TRACE, "{}: MD-SAL flow ID is already resolved: {}", vtnId.getValue(), id.getValue()); } else { ctx.log(LOG, VTNLogLevel.DEBUG, "{}: Associated with MD-SAL flow ID: {}", vtnId.getValue(), mdId.getValue()); } else { ctx.log(LOG, VTNLogLevel.INFO, "{}: MD-SAL flow ID has been changed: {} -> {}", vtnId.getValue(), id.getValue(), mdId.getValue());
/** * To delete Arp flows in the given node. * @param nodeId : nodeId */ private void deleteArpFlow(NodeId nodeId) { List<Flow> flowList = getFlowList(nodeId); for (Flow flow : flowList) { String flowId = flow.getId().toString(); if (flowId.contains(ARP_REPLY_TO_CONTROLLER_FLOW_NAME)) { deleteFlow(nodeId, flow); } } }
/** * Starts and commits data change transaction which modifies provided * flow path with supplied body. */ private Future<RpcResult<AddFlowOutput>> writeFlowToSwitch(NodeId nodeId, Flow flow) { InstanceIdentifier<Node> nodeInstanceId = InstanceIdentifier.<Nodes>builder(Nodes.class) .<Node, NodeKey>child(Node.class, new NodeKey(nodeId)).build(); InstanceIdentifier<Table> tableInstanceId = nodeInstanceId .<FlowCapableNode>augmentation(FlowCapableNode.class) .<Table, TableKey>child(Table.class, new TableKey(flowTableId)); InstanceIdentifier<Flow> flowPath = tableInstanceId.<Flow, FlowKey>child(Flow.class, new FlowKey(new FlowId(String.valueOf(flowIdInc.getAndIncrement())))); final AddFlowInputBuilder builder = new AddFlowInputBuilder(flow).setNode(new NodeRef(nodeInstanceId)) .setFlowTable(new FlowTableRef(tableInstanceId)).setFlowRef(new FlowRef(flowPath)) .setTransactionUri(new Uri(flow.getId().getValue())); return salFlowService.addFlow(builder.build()); } }
/** * To remove redirect flows in the given nodes. * @param nodeId : nodeId * @param intent : intent */ private void removeRedirectFlow(NodeId nodeId, Intent intent) { List<Flow> flowList = getFlowList(nodeId); List<String> endPointGroups = IntentUtils.extractEndPointGroup(intent); String endPointGroupsFroward = createRedirectFlowName(endPointGroups); Collections.reverse(endPointGroups); String endPointGroupsReverse = createRedirectFlowName(endPointGroups); for (Flow flow : flowList) { String flowId = flow.getId().toString(); if (flowId.contains(endPointGroupsFroward) || flowId.contains(endPointGroupsReverse)) { deleteFlow(nodeId, flow); } } }
/** * For flow without match specified (actually, only "drop all" flow) * * @param prefix String * @return FlowId */ public static FlowId newFlowId(String prefix) { return new FlowId(prefix); }
InstanceIdentifier <Table> tableId = nodeId.builder().augmentation(FlowCapableNode.class).child(Table.class, tableKey).build(); Long nodeFlowId = lacpFlowId.getAndIncrement(); FlowId flowId = new FlowId(String.valueOf(nodeFlowId)); FlowKey flowKey = new FlowKey(flowId); InstanceIdentifier <Flow> lacpFId = tableId.child(Flow.class, flowKey); builder.setFlowRef(new FlowRef(lacpFId)); builder.setFlowTable(new FlowTableRef(tableId)); builder.setTransactionUri(new Uri(lacpFlow.getId().getValue())); try
private void notifyTaskIfRequired(BigInteger dpId, Flow flow) { FlowInfoKey flowKey = new FlowInfoKey(dpId, flow.getTableId(), flow.getMatch(), flow.getId().getValue()); Runnable notifyTask = flowMap.remove(flowKey); if (notifyTask == null) { return; } executorService.execute(notifyTask); }
public void writeFlow(MacAddress srcMac, MacAddress dstMac, NodeConnectorRef dstNodeConnectorRef, Long meterId) { LOG.info("in flowManager.addFlow"); if(srcMac != null && dstMac.equals(srcMac)) { LOG.info("In addMacToMacFlow: No flows added. Source and Destination MAC are same."); return; } TableKey flowTableKey = new TableKey(flowTableId); InstanceIdentifier<Flow> flowPath = buildFlowPath(createMacMatch(srcMac, dstMac), dstNodeConnectorRef, flowTableKey); FlowId flowId = flowPath.firstKeyOf(Flow.class).getId(); LOG.info("flowPath: " + flowPath.toString()); LOG.info("flowId: " + flowId.toString()); Flow flowBody = createMacToMacFlow(flowId, flowTableKey.getId(), DEFAULT_PRIORITY, srcMac, dstMac, meterId, dstNodeConnectorRef); LOG.info("flowBody: " + flowBody.toString()); WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowPath, flowBody, true); try { writeTransaction.submit().checkedGet(); } catch (TransactionCommitFailedException e) { LOG.error("Transaction failed: {}", e.toString()); } LOG.info("Transaction succeeded"); }
public static FlowId getDefaultInstance(String defaultValue) { return new FlowId(defaultValue); }
InstanceIdentifier <Table> tableId = nodeId.builder().augmentation(FlowCapableNode.class).child(Table.class, tableKey).build(); Long nodeFlowId = lacpNode.getFlowId(); FlowId flowId = new FlowId(String.valueOf(nodeFlowId)); FlowKey flowKey = new FlowKey(flowId); InstanceIdentifier <Flow> lacpFId = tableId.child(Flow.class, flowKey); builder.setFlowRef(new FlowRef(lacpFId)); builder.setFlowTable(new FlowTableRef(tableId)); builder.setTransactionUri(new Uri(lacpFlow.getId().getValue())); Future<RpcResult<RemoveFlowOutput>> result = salFlow.removeFlow(builder.build()); try
/** * Add the given flow information into this instance. * * @param data An {@link IdentifiedData} instance which contains * flow statistics. */ public void add(IdentifiedData<Flow> data) { Flow flow = data.getValue(); FlowCookie cookie = flow.getCookie(); VtnFlowId vtnId = FlowUtils.getVtnFlowId(cookie); if (vtnId == null) { LOG.debug("{}: Unwanted flow cookie: {}", flow.getId().getValue(), cookie); } else { InstanceIdentifier<Flow> path = data.getIdentifier(); SalNode snode = SalNode.create(path.firstKeyOf(Node.class)); if (snode == null) { LOG.debug("{}: Invalid flow path: {}", flow.getId().getValue(), path); } else { Map<SalNode, Flow> flowMap = addedFlows.get(vtnId); if (flowMap == null) { flowMap = new HashMap<>(); addedFlows.put(vtnId, flowMap); } flowMap.put(snode, flow); } } }
public void writeFlow(Ipv4Address srcIp, Ipv4Address dstIp, NodeConnectorRef dstNodeConnectorRef, Long meterId) { LOG.info("in flowManager.addFlow"); if(srcIp != null && dstIp.equals(srcIp)) { LOG.info("In addIpv4ToIpv4Flow: No flows added. Source and Destination mac are same."); return; } TableKey flowTableKey = new TableKey(flowTableId); InstanceIdentifier<Flow> flowPath = buildFlowPath(createIpv4Match(srcIp, dstIp), dstNodeConnectorRef, flowTableKey); FlowId flowId = flowPath.firstKeyOf(Flow.class).getId(); LOG.info("flowPath: " + flowPath.toString()); LOG.info("flowId: " + flowId.toString()); Flow flowBody = createIpv4ToIpv4Flow(flowId, flowTableKey.getId(), DEFAULT_PRIORITY, srcIp, dstIp, meterId, dstNodeConnectorRef); LOG.info("flowBody: " + flowBody.toString()); WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); writeTransaction.put(LogicalDatastoreType.CONFIGURATION, flowPath, flowBody, true); try { writeTransaction.submit().checkedGet(); } catch (TransactionCommitFailedException e) { LOG.error("Transaction failed: {}", e.toString()); } LOG.info("Transaction succeed"); }
private FlowId createFlowId(EthernetMatch ethernetMatch, ArpMatch arpMatch) { StringBuilder sb = new StringBuilder(); sb.append(ARP_REPLY_TO_CONTROLLER_FLOW_NAME); sb.append("|").append(ethernetMatch); sb.append("|").append(arpMatch); return new FlowId(sb.toString()); }
/** * {@inheritDoc} */ @Override protected void execute(ReadWriteTransaction tx) { removedFlow = null; // Fetch the target flow entry. LogicalDatastoreType oper = LogicalDatastoreType.OPERATIONAL; Optional<Flow> opt = DataStoreUtils.read(tx, oper, flowPath); if (opt.isPresent()) { Flow flow = opt.get(); if (targetFlow.equalsFlow(flow) && cookieMatcher.match(flow)) { // Delete the target flow entry. tx.delete(oper, flowPath); removedFlow = flow.getId().getValue(); } } }
/** * FlowId based on match (with prefix like "t2|localL3|") * * @param tableId Short * @param prefix String * @param match Match * @return FlowId */ public static FlowId newFlowId(Short tableId, String prefix, Match match) { return new FlowId((tableId != null ? TABLE_ID_PREFIX + tableId + FLOWID_SEPARATOR : "") + prefix + FLOWID_SEPARATOR + formatMatch(match)); }
void removeUnreportedFlows(final ReadWriteTransaction tx) { final InstanceIdentifier<Node> nodeIdent = tableRef.firstIdentifierOf(Node.class); final List<InstanceIdentifier<Flow>> listMissingConfigFlows = notStatReportedConfigFlows(); final Map<InstanceIdentifier<Flow>, Integer> nodeDeleteMap = mapNodesForDelete.get(nodeIdent); final Map<FlowHashIdMapKey, FlowId> listForRemove = getRemovalList(); for (final Entry<FlowHashIdMapKey, FlowId> entryForRemove : listForRemove.entrySet()) { final FlowKey flowKey = new FlowKey(entryForRemove.getValue()); final InstanceIdentifier<Flow> flowRef = tableRef.child(Flow.class, flowKey); if (nodeDeleteMap != null && flowKey.getId().getValue().startsWith(ALIEN_SYSTEM_FLOW_ID)) { final Integer lifeIndex = nodeDeleteMap.get(flowRef); if (lifeIndex != null && lifeIndex > 0) { break; } else { nodeDeleteMap.remove(flowRef); } } else { if (listMissingConfigFlows.remove(flowRef)) { // it is probable that some multipart message was lost break; } } final InstanceIdentifier<FlowHashIdMap> flHashIdent = tableRef.augmentation(FlowHashIdMapping.class).child(FlowHashIdMap.class, entryForRemove.getKey()); tx.delete(LogicalDatastoreType.OPERATIONAL, flowRef); tx.delete(LogicalDatastoreType.OPERATIONAL, flHashIdent); } }