@Nonnull @Override public ListenableFuture<Node> onNodeUpdated(@Nonnull final NodeId nodeId, @Nonnull final Node configNode) { // update magic return Futures.immediateFuture(new NodeBuilder().addAugmentation(NetconfNode.class, new NetconfNodeBuilder().setConnectionStatus(NetconfNodeFields.ConnectionStatus.Connected).build()).build()); }
public synchronized Node getNode() { List<AttachmentPoints> attachmentPoints = new ArrayList<>(); for (AttachmentPointsBuilder apb : apbs) { attachmentPoints.add(apb.build()); } hostNodeBuilder.setAttachmentPoints(attachmentPoints); return nodeBuilder.addAugmentation(HostNode.class, hostNodeBuilder.build()).build(); }
@Nonnull @Override public ListenableFuture<Node> onNodeCreated(@Nonnull final NodeId nodeId, @Nonnull final Node configNode) { return Futures.immediateFuture(new NodeBuilder().addAugmentation(NetconfNode.class, new NetconfNodeBuilder().setConnectionStatus(NetconfNodeFields.ConnectionStatus.Connected).build()).build()); }
@Nonnull @Override public Node getFailedState(@Nonnull final NodeId nodeId, @Nonnull final Node configNode) { return new NodeBuilder().addAugmentation(NetconfNode.class, new NetconfNodeBuilder().setConnectionStatus(NetconfNodeFields.ConnectionStatus.UnableToConnect).build()).build(); }
public synchronized Node getHostNode() { List<AttachmentPoints> attachmentPoints = new ArrayList<>(); for (AttachmentPointsBuilder apb : apbs) { attachmentPoints.add(apb.build()); } hostNodeBuilder.setAttachmentPoints(attachmentPoints); return nodeBuilder.addAugmentation(HostNode.class, hostNodeBuilder.build()).build(); }
@Nonnull @Override public Node getInitialState(@Nonnull final NodeId nodeId, @Nonnull final Node configNode) { return new NodeBuilder().addAugmentation(NetconfNode.class, new NetconfNodeBuilder().setConnectionStatus(NetconfNodeFields.ConnectionStatus.Connecting).build()).build(); }
public void setDeviceAsFailed(Throwable throwable) { String reason = (throwable != null && throwable.getMessage() != null) ? throwable.getMessage() : UNKNOWN_REASON; final NetconfNode netconfNode = new NetconfNodeBuilder().setConnectionStatus(ConnectionStatus.UnableToConnect).setConnectedMessage(reason).build(); final Node data = getNodeIdBuilder(id).addAugmentation(NetconfNode.class, netconfNode).build(); final WriteTransaction writeTx = txChain.newWriteOnlyTransaction(); logger.trace("{}: Setting device state as failed {} putting operational data started.", id, writeTx.getIdentifier()); writeTx.put(LogicalDatastoreType.OPERATIONAL, id.getTopologyBindingPath(), data); logger.trace("{}: Setting device state as failed {} putting operational data ended.", id, writeTx.getIdentifier()); commitTransaction(writeTx, "update-failed-device"); }
@Override public ListenableFuture<Void> apply(Optional<BridgeDomain> optBridgeDomainConf) throws Exception { if (optBridgeDomainConf.isPresent() && optBridgeDomainConf.get().getPhysicalLocationRef() != null) { for (PhysicalLocationRef ref : optBridgeDomainConf.get().getPhysicalLocationRef()) { if (!ref.getNodeId().equals(vppNodeId)) continue; //not our referenced node skipping if (ref.getInterface() != null && ref.getInterface().size() > 0) { NodeVbridgeVlanAugment vppNodeVlanAug = new NodeVbridgeVlanAugmentBuilder() .setSuperInterface(ref.getInterface().get(0)).build(); Node vppNode = createBasicVppNodeBuilder(vppNodeId) .addAugmentation(NodeVbridgeVlanAugment.class, vppNodeVlanAug).build(); return createBridgeDomainOnVppNode(bridgeDomainName, topoAug, vppNode); } } } return Futures.immediateFailedFuture( new Throwable("Failed to apply config for VLAN bridge domain " + bridgeDomainName)); } });
private Node buildDataForNetconfNode(boolean up, NetconfDeviceCapabilities capabilities) { List<String> capabilityList = new ArrayList<>(); capabilityList.addAll(capabilities.getNonModuleBasedCapabilities()); capabilityList.addAll(FluentIterable.from(capabilities.getResolvedCapabilities()).transform(AVAILABLE_CAPABILITY_TRANSFORMER).toList()); final AvailableCapabilitiesBuilder avCapabalitiesBuilder = new AvailableCapabilitiesBuilder(); avCapabalitiesBuilder.setAvailableCapability(capabilityList); final UnavailableCapabilities unavailableCapabilities = new UnavailableCapabilitiesBuilder().setUnavailableCapability(FluentIterable.from(capabilities.getUnresolvedCapabilites().entrySet()) .transform(UNAVAILABLE_CAPABILITY_TRANSFORMER).toList()).build(); final NetconfNodeBuilder netconfNodeBuilder = new NetconfNodeBuilder() .setHost(id.getHost()) .setPort(new PortNumber(id.getAddress().getPort())) .setConnectionStatus(up ? ConnectionStatus.Connected : ConnectionStatus.Connecting) .setAvailableCapabilities(avCapabalitiesBuilder.build()) .setUnavailableCapabilities(unavailableCapabilities); final NodeBuilder nodeBuilder = getNodeIdBuilder(id); return nodeBuilder.addAugmentation(NetconfNode.class, netconfNodeBuilder.build()).build(); }
public static org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node toTopologyNode( final NodeId nodeId, final NodeRef invNodeRef) { return new NodeBuilder() .setNodeId(nodeId) .addAugmentation(InventoryNode.class, new InventoryNodeBuilder() .setInventoryNodeRef(invNodeRef) .build()) .build(); }
private Node buildConnectionNode( Bridge bridge) { //Update node with managed node reference NodeBuilder connectionNode = new NodeBuilder(); connectionNode.setNodeId(getOvsdbConnectionInstance().getNodeId()); OvsdbNodeAugmentationBuilder ovsdbConnectionAugmentationBuilder = new OvsdbNodeAugmentationBuilder(); List<ManagedNodeEntry> managedBridges = new ArrayList<>(); InstanceIdentifier<Node> bridgeIid = SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(), bridge); ManagedNodeEntry managedBridge = new ManagedNodeEntryBuilder().setBridgeRef( new OvsdbBridgeRef(bridgeIid)).build(); managedBridges.add(managedBridge); ovsdbConnectionAugmentationBuilder.setManagedNodeEntry(managedBridges); connectionNode.addAugmentation(OvsdbNodeAugmentation.class, ovsdbConnectionAugmentationBuilder.build()); LOG.debug("Update node with bridge node ref {}", ovsdbConnectionAugmentationBuilder.getManagedNodeEntry().iterator().next()); return connectionNode.build(); }
public static Node createNode(ConnectionInfo key) { NodeBuilder nodeBuilder = new NodeBuilder(); nodeBuilder.setNodeId(createNodeId(key.getRemoteIp(), key.getRemotePort())); nodeBuilder.addAugmentation(OvsdbNodeAugmentation.class, createOvsdbAugmentation(key)); return nodeBuilder.build(); }
private InstanceIdentifier<IgpNodeAttributes> ensureNodePresent(final ReadWriteTransaction trans, final NodeId ni) { final NodeUsage present = this.nodes.get(ni); if (present != null) { return present.attrId; } final KeyedInstanceIdentifier<Node, NodeKey> nii = nodeInstanceId(ni); final InstanceIdentifier<IgpNodeAttributes> ret = nii.builder().augmentation(Node1.class).child(IgpNodeAttributes.class).build(); trans.merge(LogicalDatastoreType.OPERATIONAL, nii, new NodeBuilder().setKey(nii.getKey()).setNodeId(ni) .addAugmentation(Node1.class, new Node1Builder().setIgpNodeAttributes( new IgpNodeAttributesBuilder().setPrefix(Collections.<Prefix>emptyList()).build()).build()).build()); this.nodes.put(ni, new NodeUsage(ret)); return ret; }
private static org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node prepareTopologyNode(final NodeId nodeIdInTopology, final InstanceIdentifier<FlowCapableNode> iiToNodeInInventory) { final InventoryNode inventoryNode = new InventoryNodeBuilder() .setInventoryNodeRef(new NodeRef(iiToNodeInInventory.firstIdentifierOf(Node.class))) .build(); final NodeBuilder topologyNodeBuilder = new NodeBuilder(); topologyNodeBuilder.setNodeId(nodeIdInTopology); topologyNodeBuilder.addAugmentation(InventoryNode.class, inventoryNode); return topologyNodeBuilder.build(); }
private void initDeviceData() { final WriteTransaction writeTx = txChain.newWriteOnlyTransaction(); createNetworkTopologyIfNotPresent(writeTx); final InstanceIdentifier<Node> path = id.getTopologyBindingPath(); NodeBuilder nodeBuilder = getNodeIdBuilder(id); NetconfNodeBuilder netconfNodeBuilder = new NetconfNodeBuilder(); netconfNodeBuilder.setConnectionStatus(ConnectionStatus.Connecting); netconfNodeBuilder.setHost(id.getHost()); netconfNodeBuilder.setPort(new PortNumber(id.getAddress().getPort())); nodeBuilder.addAugmentation(NetconfNode.class, netconfNodeBuilder.build()); Node node = nodeBuilder.build(); logger.trace("{}: Init device state transaction {} putting if absent operational data started.", id, writeTx.getIdentifier()); writeTx.put(LogicalDatastoreType.OPERATIONAL, path, node); logger.trace("{}: Init device state transaction {} putting operational data ended.", id, writeTx.getIdentifier()); logger.trace("{}: Init device state transaction {} putting if absent config data started.", id, writeTx.getIdentifier()); writeTx.put(LogicalDatastoreType.CONFIGURATION, path, getNodeWithId(id)); logger.trace("{}: Init device state transaction {} putting config data ended.", id, writeTx.getIdentifier()); commitTransaction(writeTx, "init"); }
/** * Create a new node in the network topology. * * @param node An {@link OfNode} instance. * @return A node in the network topology. */ public static Node newTopologyNode(OfNode node) { InventoryNode invNode = new InventoryNodeBuilder(). setInventoryNodeRef(node.getNodeRef()). build(); return new NodeBuilder(). setNodeId(new NodeId(node.getNodeIdentifier())). addAugmentation(InventoryNode.class, invNode). build(); }
public static Node createBasicVcNetNode() { /* * Node <-- VcNode <>-- VcNodeAttributes <-- VcNetNode <>-- NetNodeAttributes */ NetNodeAttributesBuilder netNodeAttrBuilder = new NetNodeAttributesBuilder(); netNodeAttrBuilder.setIsNetNodeEmpty(true); VcNetNodeBuilder vcNetNodeBuilder = new VcNetNodeBuilder(); vcNetNodeBuilder.setNetNodeAttributes(netNodeAttrBuilder.build()); VcNode baseVcNode = createBasicVcNode(VC_NET_NODE_NAME); VcNodeAttributesBuilder vcNodeAttrBuilder = new VcNodeAttributesBuilder(baseVcNode.getVcNodeAttributes()); vcNodeAttrBuilder.addAugmentation(VcNetNode.class, vcNetNodeBuilder.build()); VcNodeBuilder vcNodeBuilder = new VcNodeBuilder(); vcNodeBuilder.setVcNodeAttributes(vcNodeAttrBuilder.build()); Node baseNode = createBasicNode(VC_NET_NODE_NAME); NodeBuilder nodeBuilder = new NodeBuilder(baseNode); nodeBuilder.addAugmentation(VcNode.class, vcNodeBuilder.build()); return nodeBuilder.build(); }
private Node buildBridgeNode(Bridge bridge) { NodeBuilder bridgeNodeBuilder = new NodeBuilder(); NodeId bridgeNodeId = getNodeId(bridge); bridgeNodeBuilder.setNodeId(bridgeNodeId); OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder(); ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridge.getName())); ovsdbBridgeAugmentationBuilder.setBridgeUuid(new Uuid(bridge.getUuid().toString())); setDataPath(ovsdbBridgeAugmentationBuilder, bridge); setDataPathType(ovsdbBridgeAugmentationBuilder, bridge); setProtocol(ovsdbBridgeAugmentationBuilder, bridge); setExternalIds(ovsdbBridgeAugmentationBuilder, bridge); setOtherConfig(ovsdbBridgeAugmentationBuilder, bridge); setFailMode(ovsdbBridgeAugmentationBuilder, bridge); setOpenFlowNodeRef(ovsdbBridgeAugmentationBuilder, bridge); setManagedBy(ovsdbBridgeAugmentationBuilder); setAutoAttach(ovsdbBridgeAugmentationBuilder, bridge); bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build()); LOG.debug("Built with the intent to store bridge data {}", ovsdbBridgeAugmentationBuilder.build()); return bridgeNodeBuilder.build(); }
public static Node createBasicVcLdNode() { /* * Node <-- VcNode <>-- VcNodeAttributes <-- VcLdNode <>-- LdNodeAttributes */ LdNodeAttributesBuilder ldNodeAttrBuilder = new LdNodeAttributesBuilder(); ldNodeAttrBuilder.setIsLdNodeEmpty(true); VcLdNodeBuilder vcLdNodeBuilder = new VcLdNodeBuilder(); vcLdNodeBuilder.setLdNodeAttributes(ldNodeAttrBuilder.build()); VcNode baseVcNode = createBasicVcNode(VC_LD_NODE_NAME); VcNodeAttributesBuilder vcNodeAttrBuilder = new VcNodeAttributesBuilder(baseVcNode.getVcNodeAttributes()); vcNodeAttrBuilder.addAugmentation(VcLdNode.class, vcLdNodeBuilder.build()); VcNodeBuilder vcNodeBuilder = new VcNodeBuilder(); vcNodeBuilder.setVcNodeAttributes(vcNodeAttrBuilder.build()); Node baseNode = createBasicNode(VC_LD_NODE_NAME); NodeBuilder nodeBuilder = new NodeBuilder(baseNode); nodeBuilder.addAugmentation(VcNode.class, vcNodeBuilder.build()); return nodeBuilder.build(); }
public static Node addVfabListToVcLdNode(Node ldNode, List<Vfabric> vfabricList) { /* * Node <-- VcNode <>-- VcNodeAttributes <-- VcLdNode <>-- LdNodeAttributes <>-- vfabrics */ VcNode oldVcNode = ldNode.getAugmentation(VcNode.class); VcNodeAttributes oldVcNodeAttr = oldVcNode.getVcNodeAttributes(); VcLdNode oldVcLdNode = oldVcNodeAttr.getAugmentation(VcLdNode.class); LdNodeAttributes oldVcLdNodeAttr = oldVcLdNode.getLdNodeAttributes(); LdNodeAttributesBuilder ldNodeAttrBuilder = new LdNodeAttributesBuilder(oldVcLdNodeAttr); ldNodeAttrBuilder.setVfabric(vfabricList); ldNodeAttrBuilder.setIsLdNodeEmpty(false); VcLdNodeBuilder vcLdNodeBuilder = new VcLdNodeBuilder(oldVcLdNode); vcLdNodeBuilder.setLdNodeAttributes(ldNodeAttrBuilder.build()); VcNodeAttributesBuilder vcNodeAttrBuilder = new VcNodeAttributesBuilder(oldVcNodeAttr); vcNodeAttrBuilder.addAugmentation(VcLdNode.class, vcLdNodeBuilder.build()); VcNodeBuilder vcNodeBuilder = new VcNodeBuilder(oldVcNode); vcNodeBuilder.setVcNodeAttributes(vcNodeAttrBuilder.build()); NodeBuilder nodeBuilder = new NodeBuilder(ldNode); nodeBuilder.addAugmentation(VcNode.class, vcNodeBuilder.build()); return nodeBuilder.build(); }