default Predicate<OneEidTableDetails> subtableFilterForLocalMappings( @Nonnull final InstanceIdentifier<LocalMapping> identifier) { if (identifier.firstIdentifierOf(VrfSubtable.class) != null) { return VRF_MAPPINGS_ONLY; } else if (identifier.firstIdentifierOf(BridgeDomainSubtable.class) != null) { return BRIDGE_DOMAIN_MAPPINGS_ONLY; } else { throw new IllegalArgumentException("Cannot determine mappings predicate for " + identifier); } }
private Node getNode(Map<InstanceIdentifier<?>, DataObject> changes, Map.Entry<InstanceIdentifier<?>, DataObject> change) { InstanceIdentifier<Node> nodeInstanceIdentifier = change.getKey().firstIdentifierOf(Node.class); return (Node)changes.get(nodeInstanceIdentifier); }
private Node getNode(Map<InstanceIdentifier<?>, DataObject> changes, Map.Entry<InstanceIdentifier<?>, DataObject> change) { InstanceIdentifier<Node> nodeInstanceIdentifier = change.getKey().firstIdentifierOf(Node.class); return (Node)changes.get(nodeInstanceIdentifier); }
/** * @param nodeConnectorRef * @return */ public static InstanceIdentifier<Node> generateNodeInstanceIdentifier(final NodeConnectorRef nodeConnectorRef) { return nodeConnectorRef.getValue().firstIdentifierOf(Node.class); }
/** * Return a reference to the node that contains this flow table. * * @return A reference to the node that contains this flow table. */ private NodeRef getNodeRef() { return new NodeRef(tablePath.firstIdentifierOf(Node.class)); }
@SuppressWarnings("unchecked") private void removeData(final Set<InstanceIdentifier<?>> removeData, final Map<InstanceIdentifier<?>, DataObject> originalData) { for (InstanceIdentifier<?> key : removeData) { if (clazz.equals(key.getTargetType())) { final InstanceIdentifier<T> ident = key.firstIdentifierOf(clazz); final DataObject removeValue = originalData.get(key); this.remove(ident, (T)removeValue); } } }
@SuppressWarnings("unchecked") private void removeData(final Set<InstanceIdentifier<?>> removeData, final Map<InstanceIdentifier<?>, DataObject> originalData) { for (InstanceIdentifier<?> key : removeData) { if (clazz.equals(key.getTargetType())) { final InstanceIdentifier<T> ident = key.firstIdentifierOf(clazz); final DataObject removeValue = originalData.get(key); this.remove(ident, (T)removeValue); } } }
private void checkProperInterfaceType(@Nonnull final WriteContext writeContext, @Nonnull final InstanceIdentifier<D> id) { final InstanceIdentifier<Interface> ifcTypeFromIid = id.firstIdentifierOf(Interface.class); checkArgument(ifcTypeFromIid != null, "Instance identifier does not contain {} type", Interface.class); checkArgument(id.firstKeyOf(Interface.class) != null, "Instance identifier does not contain keyed {} type", Interface.class); final Optional<Interface> interfaceConfig = writeContext.readAfter(ifcTypeFromIid); checkState(interfaceConfig.isPresent(), "Unable to get Interface configuration for an interface: %s currently being updated", ifcTypeFromIid); IllegalInterfaceTypeException .checkInterfaceType(interfaceConfig.get(), getExpectedInterfaceType()); }
public void remove(InstanceIdentifier<O> identifier , O del){ final D notif = deleteNotification(identifier.firstIdentifierOf(clazz)); if (notif != null) { notificationProviderService.publish(notif); } }
public static long getSwitchId(NodeConnectorRef portRef) { long result = 0; if (portRef != null) { InstanceIdentifier<NodeConnector> nodeConnectorInstanceId = (InstanceIdentifier<NodeConnector>)portRef.getValue(); InstanceIdentifier<Node> nodeId = (InstanceIdentifier<Node>) nodeConnectorInstanceId.firstIdentifierOf(Node.class); result = LacpUtil.getNodeSwitchId(nodeId); } return result; } private static NodeConnector readNodeConnector (NodeConnectorRef ncRef)
@Override public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception { fabricObj.notifyRouteUpdated(routesIId.firstIdentifierOf(Node.class), routes, true); return Futures.immediateFuture(RpcResultBuilder.<Void>success().build()); } }, executor);
@Override public void onNodeRemoved(final NodeRemoved notification) { Preconditions.checkNotNull(notification); final NodeRef nodeRef = notification.getNodeRef(); final InstanceIdentifier<?> nodeRefIdent = nodeRef.getValue(); final InstanceIdentifier<Node> nodeIdent = nodeRefIdent.firstIdentifierOf(Node.class); if (nodeIdent != null) { disconnectFlowCapableNode(nodeIdent); } }
@Override public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception { fabricObj.notifyRouteUpdated(routesIId.firstIdentifierOf(Node.class), routes, false); return Futures.immediateFuture(RpcResultBuilder.<Void>success().build()); } }, executor);
@Override public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception { fabricObj.notifyRouteCleared(routesIId.firstIdentifierOf(Node.class)); return Futures.immediateFuture(RpcResultBuilder.<Void>success().build()); } }, executor);
private void processFloatingIPAdd(final InstanceIdentifier<IpMapping> identifier, final IpMapping mapping) { LOG.trace("Add event - key: {}, value: {}", identifier, mapping); final String routerId = identifier.firstKeyOf(RouterPorts.class).getRouterId(); final PortsKey pKey = identifier.firstKeyOf(Ports.class); String interfaceName = pKey.getPortName(); InstanceIdentifier<RouterPorts> pIdentifier = identifier.firstIdentifierOf(RouterPorts.class); createNATFlowEntries(interfaceName, mapping, pIdentifier, routerId); }
private void processRemovedConnector(final DataTreeModification<T> modification) { final InstanceIdentifier<T> identifier = modification.getRootPath().getRootIdentifier(); if (compareIITail(identifier, II_TO_FLOW_CAPABLE_NODE_CONNECTOR)) { InstanceIdentifier<NodeConnector> nodeConnectorInstanceId = identifier.firstIdentifierOf(NodeConnector.class); notifyNodeConnectorDisappeared(nodeConnectorInstanceId); } }
private String getDpnIdFromNodeConnector(DataTreeModification<FlowCapableNodeConnector> newDataObject) { InstanceIdentifier<FlowCapableNodeConnector> key = newDataObject.getRootPath().getRootIdentifier(); NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId(); String dpnFromNodeConnectorId = getDpnFromNodeConnectorId(nodeConnectorId); return dpnFromNodeConnectorId; }
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(); }
@Override public Future<RpcResult<RemoveGroupOutput>> removeWithResult(final InstanceIdentifier<Group> identifier, final Group removeDataObj, final InstanceIdentifier<FlowCapableNode> nodeIdent) { final Group group = (removeDataObj); final RemoveGroupInputBuilder builder = new RemoveGroupInputBuilder(group); builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class))); builder.setGroupRef(new GroupRef(identifier)); builder.setTransactionUri(new Uri(provider.getNewTransactionId())); return this.provider.getSalGroupService().removeGroup(builder.build()); }
@Override public Future<RpcResult<AddGroupOutput>> add( final InstanceIdentifier<Group> identifier, final Group addDataObj, final InstanceIdentifier<FlowCapableNode> nodeIdent) { final Group group = (addDataObj); final AddGroupInputBuilder builder = new AddGroupInputBuilder(group); builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class))); builder.setGroupRef(new GroupRef(identifier)); builder.setTransactionUri(new Uri(provider.getNewTransactionId())); return this.provider.getSalGroupService().addGroup(builder.build()); }