/** * Return a reference to this port. * * @return A {@link NodeConnectorRef} instance. */ public NodeConnectorRef getPortRef() { return new NodeConnectorRef(portPath); }
/** * Return a {@link NodeConnectorRef} instance corresponding to this * instance. * * @return An {@link NodeConnectorRef} instance. */ public NodeConnectorRef getNodeConnectorRef() { return new NodeConnectorRef(getNodeConnectorIdentifier()); }
public static NodeConnectorRef nodeConnectorRefFromDatapathIdPortno(final BigInteger datapathId, final Long portNo, final OpenflowVersion ofVersion, final KeyedInstanceIdentifier<Node, NodeKey> nodePath) { return new NodeConnectorRef(nodeConnectorInstanceIdentifierFromDatapathIdPortno(datapathId, portNo, ofVersion, nodePath)); }
public static NodeConnectorRef nodeConnectorRefFromDatapathIdPortno(final BigInteger datapathId, final Long portNo, final OpenflowVersion ofVersion) { return new NodeConnectorRef(nodeConnectorInstanceIdentifierFromDatapathIdPortno(datapathId, portNo, ofVersion)); }
@Override public NodeConnectorRemoved deleteNotification(final InstanceIdentifier<FlowCapableNodeConnector> path) { Preconditions.checkArgument(path != null); final NodeConnectorRemovedBuilder notifBuilder = new NodeConnectorRemovedBuilder(); notifBuilder.setNodeConnectorRef(new NodeConnectorRef(path)); return notifBuilder.build(); } }
private void publishNodeConnectorUpdate(final Map.Entry<InstanceIdentifier<?>,DataObject> entry, final UpdateType updateType) { if (entry.getKey().getTargetType().equals(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector.class)) { NodeConnectorRef nodeConnectorRef = new NodeConnectorRef(entry.getKey()); NodeConnector nodeConnector = null; try { nodeConnector = NodeMapping.toADNodeConnector(nodeConnectorRef); } catch (ConstructionException e) { LOG.debug("Construction exception: %s",e.getMessage()); } HashSet<Property> _aDNodeConnectorProperties = NodeMapping.toADNodeConnectorProperties((org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector) entry.getValue()); this.publishNodeConnectorUpdate(nodeConnector, updateType, _aDNodeConnectorProperties); } }
private boolean enqueuePortStatus (InstanceIdentifier<NodeConnector> ncId, int upDown, boolean hardReset) { boolean result = false; if (ncId != null){ short portId = NodePort.getPortId(new NodeConnectorRef(ncId)); long swId = NodePort.getSwitchId(new NodeConnectorRef(ncId)); LacpPDUPortStatusContainer pduElem = null; pduElem = new LacpPortStatus(swId,portId,upDown, ncId, hardReset); LacpPDUQueue pduQueue = LacpPDUQueue.getLacpPDUQueueInstance(); if((pduQueue!= null) && !(pduQueue.enqueue(swId,pduElem))){ LOG.debug("Failed to enque port status object for port={}",portId); result = false; } result = true; } return result; }
public boolean removeNonLacpPort (InstanceIdentifier<NodeConnector> port) { NodeConnectorId ncId = InstanceIdentifier.keyOf(port).getId(); if (ncId.getValue().contains("LOCAL")) { /* Ignoring port updates for LOCAL port connected to the controller */ LOG.debug ("getting a remove port indication for LOCAL port. ignoring it"); return false; } boolean result = false; LacpPortType pType = this.containsPort(port); if (pType == LacpPortType.NON_LACPPORT) { result = nonLacpPortList.remove(port); } else if (pType == LacpPortType.PORT_DOWN) { downPortList.remove(port); } LOG.debug("removing non lacp port {} result {}", port, result); if (result == true) { bcastGroup = groupTbl.lacpRemPort (bcastGroup, new NodeConnectorRef(port), false); } return result; } public LacpPort removeLacpPort (InstanceIdentifier<NodeConnector> portId, boolean hardReset)
public static NodeConnectorRef createNodeConnRef(final String nodeId, final String port) { StringBuilder sBuild = new StringBuilder(nodeId).append(':').append(port); NodeConnectorKey nConKey = new NodeConnectorKey(new NodeConnectorId(sBuild.toString())); InstanceIdentifier<NodeConnector> path = InstanceIdentifier.<Nodes>builder(Nodes.class) .<Node, NodeKey>child(Node.class, new NodeKey(new NodeId(nodeId))) .<NodeConnector, NodeConnectorKey>child(NodeConnector.class, nConKey) .build(); return new NodeConnectorRef(path); }
@Override protected void remove(InstanceIdentifier<NodeConnector> ident, NodeConnector removeValue) { NodeConnectorRemovedBuilder builder = new NodeConnectorRemovedBuilder(); builder.setNodeConnectorRef(new NodeConnectorRef(ident)); adapter.onNodeConnectorRemovedInternal(builder.build()); }
private static NodeConnectorRef getNodeConnRef(final String nodeId, final String port) { StringBuilder _stringBuilder = new StringBuilder(nodeId); StringBuilder _append = _stringBuilder.append(":"); StringBuilder sBuild = _append.append(port); String _string = sBuild.toString(); NodeConnectorId _nodeConnectorId = new NodeConnectorId(_string); NodeConnectorKey _nodeConnectorKey = new NodeConnectorKey(_nodeConnectorId); NodeConnectorKey nConKey = _nodeConnectorKey; InstanceIdentifierBuilder<Nodes> _builder = InstanceIdentifier.<Nodes> builder(Nodes.class); NodeId _nodeId = new NodeId(nodeId); NodeKey _nodeKey = new NodeKey(_nodeId); InstanceIdentifierBuilder<Node> _child = _builder.<Node, NodeKey> child(Node.class, _nodeKey); InstanceIdentifierBuilder<NodeConnector> _child_1 = _child.<NodeConnector, NodeConnectorKey> child( NodeConnector.class, nConKey); InstanceIdentifier<NodeConnector> path = _child_1.toInstance(); NodeConnectorRef _nodeConnectorRef = new NodeConnectorRef(path); return _nodeConnectorRef; }
public ListenableFuture<RpcResult<Void>> sendArpResponse(ArpMessageAddress senderAddress, ArpMessageAddress receiverAddress, InstanceIdentifier<NodeConnector> egressNc, Header8021q vlan) { checkNotNull(senderAddress); checkNotNull(receiverAddress); checkNotNull(egressNc); final Ethernet arpFrame = createArpFrame(senderAddress, receiverAddress, vlan); byte[] arpFrameAsBytes; try { arpFrameAsBytes = arpFrame.serialize(); } catch (PacketException e) { LOG.warn("Serializition of ARP packet is not successful.", e); if (LOG.isDebugEnabled()) { LOG.debug("ARP packet: {}", ArpUtils.getArpFrameToStringFormat(arpFrame)); } return Futures.immediateFailedFuture(e); } // Generate packet with destination switch and port LOG.debug("Egress for ARP packetOut: " + new NodeConnectorRef(egressNc).toString()); TransmitPacketInput packet = new TransmitPacketInputBuilder().setEgress(new NodeConnectorRef(egressNc)) .setNode(new NodeRef(egressNc.firstIdentifierOf(Node.class))).setPayload(arpFrameAsBytes).build(); if (LOG.isTraceEnabled()) { LOG.trace("Sending ARP RESPONSE \n{}", ArpUtils.getArpFrameToStringFormat(arpFrame)); } Future<RpcResult<Void>> futureTransmitPacketResult = packetProcessingService.transmitPacket(packet); return JdkFutureAdapters.listenInPoolThread(futureTransmitPacketResult); }
@Override public NodeConnectorUpdated createNotification(final FlowCapableNodeConnector o, final InstanceIdentifier<FlowCapableNodeConnector> path) { Preconditions.checkArgument(o != null); Preconditions.checkArgument(path != null); final NodeConnectorUpdatedBuilder notifBuilder = new NodeConnectorUpdatedBuilder(); final FlowCapableNodeConnectorUpdatedBuilder connNotifBuilder = new FlowCapableNodeConnectorUpdatedBuilder(o); notifBuilder.setId(path.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId()); notifBuilder.setNodeConnectorRef(new NodeConnectorRef(path)); notifBuilder.addAugmentation(FlowCapableNodeConnectorUpdated.class, connNotifBuilder.build()); return notifBuilder.build(); }
public static NodeConnectorRef toNodeConnectorRef(final org.opendaylight.controller.sal.core.NodeConnector nodeConnector) { final NodeRef node = NodeMapping.toNodeRef(nodeConnector.getNode()); @SuppressWarnings("unchecked") final InstanceIdentifier<Node> nodePath = ((InstanceIdentifier<Node>) node.getValue()); NodeConnectorId nodeConnectorId = null; if (nodeConnector.getID().equals(org.opendaylight.controller.sal.core.NodeConnector.SPECIALNODECONNECTORID)) { final NodeId nodeId = toNodeId(nodePath); final String nodeConnectorType = nodeConnector.getType(); if (nodeConnectorType.equals(NodeConnectorIDType.SWSTACK)) { nodeConnectorId = toLocalNodeConnectorId(nodeId); } else if (nodeConnectorType.equals(NodeConnectorIDType.HWPATH)) { nodeConnectorId = toNormalNodeConnectorId(nodeId); } else if (nodeConnectorType.equals(NodeConnectorIDType.CONTROLLER)) { nodeConnectorId = toControllerNodeConnectorId(nodeId); } } else { nodeConnectorId = new NodeConnectorId(OPENFLOW_ID_PREFIX + Arguments.<Short>checkInstanceOf(nodeConnector.getID(), Short.class)); } final NodeConnectorKey connectorKey = new NodeConnectorKey(nodeConnectorId); final InstanceIdentifier<NodeConnector> path = nodePath.child(NODECONNECTOR_CLASS, connectorKey); return new NodeConnectorRef(path); }
private static TerminationPoint prepareTopologyTerminationPoint(final TpId terminationPointIdInTopology, final InstanceIdentifier<FlowCapableNodeConnector> iiToNodeInInventory) { final InventoryNodeConnector inventoryNodeConnector = new InventoryNodeConnectorBuilder() .setInventoryNodeConnectorRef(new NodeConnectorRef(iiToNodeInInventory.firstIdentifierOf(NodeConnector.class))).build(); final TerminationPointBuilder terminationPointBuilder = new TerminationPointBuilder(); terminationPointBuilder.setTpId(terminationPointIdInTopology); terminationPointBuilder.addAugmentation(InventoryNodeConnector.class, inventoryNodeConnector); return terminationPointBuilder.build(); }
public static NodeConnectorRef getNodeConnectorRef(NodeConnectorId nodeConnectorId) { NodeId nodeId = getNodeId(nodeConnectorId); return new NodeConnectorRef(InstanceIdentifier.builder(Nodes.class) .child(Node.class, new NodeKey(nodeId)) .child(NodeConnector.class, new NodeConnectorKey(nodeConnectorId)) .build()); }
@Override protected void add(InstanceIdentifier<NodeConnector> createKeyIdent, NodeConnector node) { FlowCapableNodeConnector fcnc = node.getAugmentation(FlowCapableNodeConnector.class); if(fcnc != null) { FlowCapableNodeConnectorUpdatedBuilder fcncub = new FlowCapableNodeConnectorUpdatedBuilder(fcnc); NodeConnectorUpdatedBuilder builder = new NodeConnectorUpdatedBuilder(); builder.setId(node.getId()); builder.setNodeConnectorRef(new NodeConnectorRef(createKeyIdent)); builder.addAugmentation(FlowCapableNodeConnectorUpdated.class, fcncub.build()); adapter.onNodeConnectorUpdatedInternal(builder.build()); } }
@Override public void onPacketReceived(PacketReceived lldp) { NodeConnectorRef src = LLDPDiscoveryUtils.lldpToNodeConnectorRef(lldp.getPayload(), true); if(src != null) { LinkDiscoveredBuilder ldb = new LinkDiscoveredBuilder(); ldb.setDestination(lldp.getIngress()); ldb.setSource(new NodeConnectorRef(src)); LinkDiscovered ld = ldb.build(); manager.getNotificationService().publish(ld); LLDPLinkAger.getInstance().put(ld); } }
private LinkDiscovered makeAddLink(Edge edge){ String headNodeIdStr = null, tailNodeIdStr = null, headNcIdStr = null, tailNcIdStr = null; boolean bool = TopologyServiceUtil.getNodeAndNcIdString(edge, headNodeIdStr, tailNodeIdStr, headNcIdStr, tailNcIdStr); if(bool == false){ logger.debug("ERROR: makeAddLink(): given Edge {}, call TopologyServiceUtil.getNodeAndNcIdString() fail", edge); return null; } NodeId localNodeId = new NodeId(headNodeIdStr); NodeConnectorId localNodeConnectorId = new NodeConnectorId(headNcIdStr); InstanceIdentifier<NodeConnector> localInstanceIdentifier = InstanceIdentifier.builder(Nodes.class) .child(Node.class, new NodeKey(localNodeId)) .child(NodeConnector.class, new NodeConnectorKey(localNodeConnectorId)).toInstance(); NodeConnectorRef localNodeConnectorRef = new NodeConnectorRef(localInstanceIdentifier); NodeId remoteNodeId = new NodeId(tailNodeIdStr); NodeConnectorId remoteNodeConnectorId = new NodeConnectorId(tailNcIdStr); InstanceIdentifier<NodeConnector> remoteInstanceIdentifier = InstanceIdentifier.builder(Nodes.class) .child(Node.class, new NodeKey(remoteNodeId)) .child(NodeConnector.class, new NodeConnectorKey(remoteNodeConnectorId)).toInstance(); NodeConnectorRef remoteNodeConnectorRef = new NodeConnectorRef(remoteInstanceIdentifier); LinkDiscoveredBuilder ldb = new LinkDiscoveredBuilder(); ldb.setSource(remoteNodeConnectorRef); ldb.setDestination(localNodeConnectorRef); return((ldb.build())); }
private LinkRemoved makeRemoveLink(Edge edge){ String headNodeIdStr = null, tailNodeIdStr = null, headNcIdStr = null, tailNcIdStr = null; boolean bool = TopologyServiceUtil.getNodeAndNcIdString(edge, headNodeIdStr, tailNodeIdStr, headNcIdStr, tailNcIdStr); if(bool == false){ logger.debug("ERROR: makeAddLink(): given Edge {}, call TopologyServiceUtil.getNodeAndNcIdString() fail", edge); return null; } NodeId localNodeId = new NodeId(headNodeIdStr); NodeConnectorId localNodeConnectorId = new NodeConnectorId(headNcIdStr); InstanceIdentifier<NodeConnector> localInstanceIdentifier = InstanceIdentifier.builder(Nodes.class) .child(Node.class, new NodeKey(localNodeId)) .child(NodeConnector.class, new NodeConnectorKey(localNodeConnectorId)).toInstance(); NodeConnectorRef localNodeConnectorRef = new NodeConnectorRef(localInstanceIdentifier); NodeId remoteNodeId = new NodeId(tailNodeIdStr); NodeConnectorId remoteNodeConnectorId = new NodeConnectorId(tailNcIdStr); InstanceIdentifier<NodeConnector> remoteInstanceIdentifier = InstanceIdentifier.builder(Nodes.class) .child(Node.class, new NodeKey(remoteNodeId)) .child(NodeConnector.class, new NodeConnectorKey(remoteNodeConnectorId)).toInstance(); NodeConnectorRef remoteNodeConnectorRef = new NodeConnectorRef(remoteInstanceIdentifier); LinkRemovedBuilder ldb = new LinkRemovedBuilder(); ldb.setSource(remoteNodeConnectorRef); ldb.setDestination(localNodeConnectorRef); return((ldb.build())); }