From: Moiz Raja Date: Mon, 17 Feb 2014 23:55:59 +0000 (-0800) Subject: Switch from using xtend to java in md-sal adapters X-Git-Tag: autorelease-tag-v20140601202136_82eb3f9~408^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=c5cb36292e3e99f601d017bcbccc42709d9084d8;ds=sidebyside Switch from using xtend to java in md-sal adapters This is part of my effort to switch all xtend code in the adapters to java Change-Id: I10c679fbe5f7980facd1b5e5d2e0a5c3ae997ff6 Signed-off-by: Moiz Raja --- diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryMapping.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryMapping.java new file mode 100644 index 0000000000..2dce505d28 --- /dev/null +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryMapping.java @@ -0,0 +1,105 @@ +/** + * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.sal.compatibility; + +import org.eclipse.xtend2.lib.StringConcatenation; +import org.eclipse.xtext.xbase.lib.Conversions; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.opendaylight.controller.sal.core.Node; +import org.opendaylight.controller.sal.core.NodeConnector; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument; + +import java.util.List; + +@SuppressWarnings("all") +public class InventoryMapping { + public static NodeConnector toAdNodeConnector(final InstanceIdentifier identifier) { + final List path = identifier.getPath(); + final PathArgument lastPathArgument = IterableExtensions.last(path); + final NodeConnectorKey tpKey = ((IdentifiableItem) lastPathArgument).getKey(); + return InventoryMapping.nodeConnectorFromId(tpKey.getId().getValue()); + } + + public static Node toAdNode(final InstanceIdentifier identifier) { + final List path = identifier.getPath(); + final PathArgument lastPathArgument = IterableExtensions.last(path); + final NodeKey tpKey = ((IdentifiableItem) lastPathArgument).getKey(); + return InventoryMapping.nodeFromNodeId(tpKey.getId().getValue()); + } + + public static NodeRef toNodeRef(final Node node) { + final NodeId nodeId = new NodeId(InventoryMapping.toNodeId(node)); + final NodeKey nodeKey = new NodeKey(nodeId); + final InstanceIdentifierBuilder builder = InstanceIdentifier.builder(); + final InstanceIdentifierBuilder nodes = builder.node(Nodes.class); + final InstanceIdentifierBuilder child = + nodes.child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, nodeKey); + final InstanceIdentifier path = child.toInstance(); + return new NodeRef(path); + } + + public static NodeKey toNodeKey(final Node node) { + final NodeId nodeId = new NodeId(InventoryMapping.toNodeId(node)); + return new NodeKey(nodeId); + } + + public static NodeConnectorKey toNodeConnectorKey(final NodeConnector nc) { + final NodeConnectorId nodeConnectorId = new NodeConnectorId(InventoryMapping.toNodeConnectorId(nc)); + return new NodeConnectorKey(nodeConnectorId); + } + + public static String toNodeId(final Node node) { + final StringConcatenation builder = new StringConcatenation(); + builder.append("ad-sal:"); + builder.append(node.getType(), ""); + builder.append("::"); + builder.append(node.getNodeIDString(), ""); + return builder.toString(); + } + + public static String toNodeConnectorId(final NodeConnector nc) { + final StringConcatenation builder = new StringConcatenation(); + builder.append(InventoryMapping.toNodeId(nc.getNode()), ""); + builder.append("::"); + builder.append(nc.getNodeConnectorIDString(), ""); + return builder.toString(); + } + + public static Node nodeFromNodeId(final String nodeId) { + final String[] split = nodeId.split("::"); + return InventoryMapping.nodeFromString(split); + } + + public static NodeConnector nodeConnectorFromId(final String invId) { + final String[] split = invId.split("::"); + return InventoryMapping.nodeConnectorFromString(split); + } + + private static NodeConnector nodeConnectorFromString(final String[] string) { + final List subList = ((List)Conversions.doWrapArray(string)).subList(0, 1); + final Node node = InventoryMapping.nodeFromString(((String[])Conversions.unwrapArray(subList, String.class))); + final String index3 = string[2]; + return NodeConnector.fromStringNoNode(index3, node); + } + + private static Node nodeFromString(final String[] strings) { + String index0 = strings[0]; + final String type = index0.substring(6); + String id = strings[1]; + return Node.fromString(type, id); + } +} diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryMapping.xtend b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryMapping.xtend deleted file mode 100644 index 0ea991830b..0000000000 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryMapping.xtend +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.controller.sal.compatibility - -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef - -class InventoryMapping { - - static def org.opendaylight.controller.sal.core.NodeConnector toAdNodeConnector( - InstanceIdentifier identifier) { - val tpKey = (identifier.path.last as IdentifiableItem).key; - return nodeConnectorFromId(tpKey.id.value); - } - - static def org.opendaylight.controller.sal.core.Node toAdNode(InstanceIdentifier identifier) { - val tpKey = (identifier.path.last as IdentifiableItem).key; - return nodeFromNodeId(tpKey.id.value); - } - - - static def NodeRef toNodeRef(org.opendaylight.controller.sal.core.Node node) { - val nodeId = new NodeKey(new NodeId(node.toNodeId)) - val path = InstanceIdentifier.builder().node(Nodes).child(Node,nodeId).toInstance; - return new NodeRef(path); - } - - static def NodeKey toNodeKey(org.opendaylight.controller.sal.core.Node node) { - val nodeId = new NodeId(node.toNodeId) - return new NodeKey(nodeId); - } - - static def NodeConnectorKey toNodeConnectorKey(org.opendaylight.controller.sal.core.NodeConnector nc) { - val nodeId = new NodeConnectorId(nc.toNodeConnectorId) - return new NodeConnectorKey(nodeId); - } - - static def String toNodeId(org.opendaylight.controller.sal.core.Node node) { - '''ad-sal:«node.type»::«node.nodeIDString»''' - } - - static def String toNodeConnectorId(org.opendaylight.controller.sal.core.NodeConnector nc) { - '''«nc.node.toNodeId»::«nc.nodeConnectorIDString»''' - } - - static def org.opendaylight.controller.sal.core.Node nodeFromNodeId(String nodeId) { - return nodeFromString(nodeId.split("::")) - } - - static def nodeConnectorFromId(String invId) { - return nodeConnectorFromString(invId.split("::")); - } - - private static def org.opendaylight.controller.sal.core.NodeConnector nodeConnectorFromString(String[] string) { - val node = nodeFromString(string.subList(0, 1)); - return org.opendaylight.controller.sal.core.NodeConnector.fromStringNoNode(string.get(2), node); - } - - private static def org.opendaylight.controller.sal.core.Node nodeFromString(String[] strings) { - val type = strings.get(0).substring(6); - org.opendaylight.controller.sal.core.Node.fromString(type, strings.get(1)) - } - -} diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.java new file mode 100644 index 0000000000..0486f3422c --- /dev/null +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.java @@ -0,0 +1,396 @@ +/** + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.sal.compatibility; + +import com.google.common.base.Objects; +import com.google.common.base.Preconditions; +import org.eclipse.xtext.xbase.lib.Exceptions; +import org.opendaylight.controller.sal.common.util.Arguments; +import org.opendaylight.controller.sal.core.AdvertisedBandwidth; +import org.opendaylight.controller.sal.core.Bandwidth; +import org.opendaylight.controller.sal.core.Buffers; +import org.opendaylight.controller.sal.core.Capabilities; +import org.opendaylight.controller.sal.core.Config; +import org.opendaylight.controller.sal.core.ConstructionException; +import org.opendaylight.controller.sal.core.MacAddress; +import org.opendaylight.controller.sal.core.Name; +import org.opendaylight.controller.sal.core.NodeConnector.NodeConnectorIDType; +import org.opendaylight.controller.sal.core.PeerBandwidth; +import org.opendaylight.controller.sal.core.Property; +import org.opendaylight.controller.sal.core.SupportedBandwidth; +import org.opendaylight.controller.sal.core.Tables; +import org.opendaylight.controller.sal.core.TimeStamp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FeatureCapability; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityArpMatchIp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityFlowStats; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityIpReasm; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityPortStats; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityQueueStats; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityStp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityTableStats; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowNode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowNodeConnector; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.flow.node.SwitchFeatures; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortConfig; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortFeatures; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.flow.capable.port.State; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey; +import org.opendaylight.yangtools.yang.binding.Identifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument; + +import java.util.Date; +import java.util.HashSet; +import java.util.List; + +@SuppressWarnings("all") +public class NodeMapping { + public final static String MD_SAL_TYPE = "MD_SAL"; + + private final static Class NODE_CLASS = Node.class; + + private final static Class NODECONNECTOR_CLASS = NodeConnector.class; + + private NodeMapping() { + throw new UnsupportedOperationException("Utility class. Instantiation is not allowed."); + } + + public static org.opendaylight.controller.sal.core.Node toADNode(final InstanceIdentifier node) throws ConstructionException { + NodeId nodeId = NodeMapping.toNodeId(node); + return NodeMapping.toADNode(nodeId); + } + + public static org.opendaylight.controller.sal.core.Node toADNode(final NodeId id) { + try { + String aDNodeId = NodeMapping.toADNodeId(id); + return new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, aDNodeId); + } catch (Throwable e) { + throw Exceptions.sneakyThrow(e); + } + } + + public static NodeId toNodeId(final InstanceIdentifier node) { + Preconditions.>checkNotNull(node); + List path = node.getPath(); + Preconditions.>checkNotNull(path); + int size = path.size(); + Preconditions.checkArgument(size >= 2); + final PathArgument arg = path.get(1); + final IdentifiableItem item = Arguments.checkInstanceOf(arg, IdentifiableItem.class); + Identifier key = item.getKey(); + final NodeKey nodeKey = Arguments.checkInstanceOf(key, NodeKey.class); + return nodeKey.getId(); + } + + public static String toADNodeId(final NodeId nodeId) { + Preconditions.checkNotNull(nodeId); + return nodeId.getValue(); + } + + public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorRef source) throws ConstructionException { + Preconditions.checkNotNull(source); + final InstanceIdentifier path = Preconditions.>checkNotNull(source.getValue()); + Preconditions.checkArgument(path.getPath().size() >= 3); + final PathArgument arg = path.getPath().get(2); + final IdentifiableItem item = Arguments.checkInstanceOf(arg,IdentifiableItem.class); + final NodeConnectorKey connectorKey = Arguments.checkInstanceOf(item.getKey(), NodeConnectorKey.class); + return NodeMapping.toADNodeConnector(connectorKey.getId(), NodeMapping.toNodeId(path)); + } + + public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorId ncid, final NodeId nid) { + try { + String nodeConnectorType = NodeMapping.toNodeConnectorType(ncid, nid); + Object aDNodeConnectorId = NodeMapping.toADNodeConnectorId(ncid, nid); + org.opendaylight.controller.sal.core.Node aDNode = NodeMapping.toADNode(nid); + return new org.opendaylight.controller.sal.core.NodeConnector(nodeConnectorType, aDNodeConnectorId, aDNode); + } catch (Throwable e) { + throw Exceptions.sneakyThrow(e); + } + } + + public static String toNodeConnectorType(final NodeConnectorId ncId, final NodeId nodeId) { + if (ncId.equals(toLocalNodeConnectorId(nodeId))) { + return NodeConnectorIDType.SWSTACK; + } else if (ncId.equals(toNormalNodeConnectorId(nodeId))) { + return NodeConnectorIDType.HWPATH; + } else if (ncId.equals(toControllerNodeConnectorId(nodeId))) { + return NodeConnectorIDType.CONTROLLER; + } + return MD_SAL_TYPE; + } + + public static Object toADNodeConnectorId(final NodeConnectorId nodeConnectorId, final NodeId nodeId) { + if (nodeConnectorId.equals(toLocalNodeConnectorId(nodeId)) || + nodeConnectorId.equals(toNormalNodeConnectorId(nodeId)) || + nodeConnectorId.equals(toControllerNodeConnectorId(nodeId))) { + return org.opendaylight.controller.sal.core.NodeConnector.SPECIALNODECONNECTORID; + } + return nodeConnectorId.getValue(); + } + + public static NodeConnectorId toControllerNodeConnectorId(final NodeId node) { + return new NodeConnectorId(node.getValue() + ":" + 4294967293L); + } + + public static NodeConnectorId toLocalNodeConnectorId(final NodeId node) { + return new NodeConnectorId(node.getValue() + ":" + 4294967294L); + } + + public static NodeConnectorId toNormalNodeConnectorId(final NodeId node) { + return new NodeConnectorId(node.getValue() + ":" + 4294967290L); + } + + public static NodeRef toNodeRef(final org.opendaylight.controller.sal.core.Node node) { + Preconditions.checkArgument(MD_SAL_TYPE.equals(node.getType())); + final String nodeId = Arguments.checkInstanceOf(node.getID(), String.class); + final NodeKey nodeKey = new NodeKey(new NodeId(nodeId)); + final InstanceIdentifier nodePath = InstanceIdentifier.builder().node(Nodes.class).child(NODE_CLASS, nodeKey).toInstance(); + return new NodeRef(nodePath); + } + + public static NodeConnectorRef toNodeConnectorRef(final org.opendaylight.controller.sal.core.NodeConnector nodeConnector) { + + final NodeRef node = NodeMapping.toNodeRef(nodeConnector.getNode()); + final InstanceIdentifier nodePath = ((InstanceIdentifier) 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(Arguments.checkInstanceOf(nodeConnector.getID(), String.class)); + } + final NodeConnectorKey connectorKey = new NodeConnectorKey(nodeConnectorId); + final InstanceIdentifier path = InstanceIdentifier.builder(nodePath).child(NODECONNECTOR_CLASS, connectorKey).toInstance(); + return new NodeConnectorRef(path); + } + + public static org.opendaylight.controller.sal.core.Node toADNode(final NodeRef node) throws ConstructionException { + return NodeMapping.toADNode(node.getValue()); + } + + public static HashSet toADNodeConnectorProperties(final NodeConnectorUpdated nc) { + final FlowCapableNodeConnectorUpdated fcncu = nc.getAugmentation(FlowCapableNodeConnectorUpdated.class); + if (!Objects.equal(fcncu, null)) { + return NodeMapping.toADNodeConnectorProperties(fcncu); + } + return new HashSet(); + } + + public static HashSet toADNodeConnectorProperties(final NodeConnector nc) { + final FlowCapableNodeConnector fcnc = nc.getAugmentation(FlowCapableNodeConnector.class); + if (!Objects.equal(fcnc, null)) { + return NodeMapping.toADNodeConnectorProperties(fcnc); + } + return new HashSet(); + } + + public static HashSet toADNodeConnectorProperties(final FlowNodeConnector fcncu) { + + final HashSet props = new HashSet<>(); + if (fcncu != null) { + if (fcncu.getCurrentFeature() != null && toAdBandwidth(fcncu.getCurrentFeature()) != null) { + props.add(toAdBandwidth(fcncu.getCurrentFeature())); + } + if (fcncu.getAdvertisedFeatures() != null && toAdAdvertizedBandwidth(fcncu.getAdvertisedFeatures()) != null) { + props.add(toAdAdvertizedBandwidth(fcncu.getAdvertisedFeatures())); + } + if (fcncu.getSupported() != null && toAdSupportedBandwidth(fcncu.getSupported()) != null) { + props.add(toAdSupportedBandwidth(fcncu.getSupported())); + } + if (fcncu.getPeerFeatures() != null && toAdPeerBandwidth(fcncu.getPeerFeatures()) != null) { + props.add(toAdPeerBandwidth(fcncu.getPeerFeatures())); + } + if (fcncu.getName() != null && toAdName(fcncu.getName()) != null) { + props.add(toAdName(fcncu.getName())); + } + if (fcncu.getConfiguration() != null && toAdConfig(fcncu.getConfiguration()) != null) { + props.add(toAdConfig(fcncu.getConfiguration())); + } + if (fcncu.getState() != null && toAdState(fcncu.getState()) != null) { + props.add(toAdState(fcncu.getState())); + } + } + return props; + } + + public static Name toAdName(final String name) { + return new Name(name); + } + + public static Config toAdConfig(final PortConfig pc) { + Config config = null; + if (pc.isPORTDOWN()) { + config = new Config(Config.ADMIN_DOWN); + } else { + config = new Config(Config.ADMIN_UP); + } + return config; + } + + public static org.opendaylight.controller.sal.core.State toAdState(final State s) { + + org.opendaylight.controller.sal.core.State state = null; + if (s.isLinkDown()) { + state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_DOWN); + } else { + state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_UP); + } + return state; + } + + public static Bandwidth toAdBandwidth(final PortFeatures pf) { + Bandwidth bw = null; + if (pf.isTenMbHd() || pf.isTenMbFd()) { + bw = new Bandwidth(Bandwidth.BW10Mbps); + } else if (pf.isHundredMbHd() || pf.isHundredMbFd()) { + bw = new Bandwidth(Bandwidth.BW100Mbps); + } else if (pf.isOneGbHd() || pf.isOneGbFd()) { + bw = new Bandwidth(Bandwidth.BW1Gbps); + } else if (pf.isOneGbFd()) { + bw = new Bandwidth(Bandwidth.BW10Gbps); + } else if (pf.isTenGbFd()) { + bw = new Bandwidth(Bandwidth.BW10Gbps); + } else if (pf.isFortyGbFd()) { + bw = new Bandwidth(Bandwidth.BW40Gbps); + } else if (pf.isHundredGbFd()) { + bw = new Bandwidth(Bandwidth.BW100Gbps); + } else if (pf.isOneTbFd()) { + bw = new Bandwidth(Bandwidth.BW1Tbps); + } + return bw; + } + + public static AdvertisedBandwidth toAdAdvertizedBandwidth(final PortFeatures pf) { + AdvertisedBandwidth abw = null; + final Bandwidth bw = toAdBandwidth(pf); + if (bw != null) { + abw = new AdvertisedBandwidth(bw.getValue()); + } + return abw; + } + + public static SupportedBandwidth toAdSupportedBandwidth(final PortFeatures pf) { + SupportedBandwidth sbw = null; + final Bandwidth bw = toAdBandwidth(pf); + if (bw != null) { + sbw = new SupportedBandwidth(bw.getValue()); + } + return sbw; + } + + public static PeerBandwidth toAdPeerBandwidth(final PortFeatures pf) { + PeerBandwidth pbw = null; + final Bandwidth bw = toAdBandwidth(pf); + if (bw != null) { + pbw = new PeerBandwidth(bw.getValue()); + } + return pbw; + } + + public static HashSet toADNodeProperties(final NodeUpdated nu) { + final FlowCapableNodeUpdated fcnu = nu.getAugmentation(FlowCapableNodeUpdated.class); + if (fcnu != null) { + return toADNodeProperties(fcnu, nu.getId()); + } + return new HashSet(); + } + + public static HashSet toADNodeProperties(final FlowNode fcnu, final NodeId id) { + + final HashSet props = new HashSet<>(); + + if (fcnu != null) { + props.add(toADTimestamp()); + + // props.add(fcnu.supportedActions.toADActions) - TODO + if (id != null) { + props.add(toADMacAddress(id)); + } + SwitchFeatures switchFeatures = fcnu.getSwitchFeatures(); + if (switchFeatures != null) { + if (switchFeatures.getMaxTables() != null) { + props.add(toADTables(switchFeatures.getMaxTables())); + } + if (switchFeatures.getCapabilities() != null) { + props.add(toADCapabiliities(switchFeatures.getCapabilities())); + } + if (switchFeatures.getMaxBuffers() != null) { + props.add(toADBuffers(switchFeatures.getMaxBuffers())); + } + } + } + return props; + } + + public static TimeStamp toADTimestamp() { + final Date date = new Date(); + final TimeStamp timestamp = new TimeStamp(date.getTime(), "connectedSince"); + return timestamp; + } + + public static MacAddress toADMacAddress(final NodeId id) { + final String nodeId = id.getValue().replaceAll("openflow:", ""); + long lNodeId = Long.parseLong(nodeId); + lNodeId = Long.valueOf(lNodeId).longValue(); + byte[] bytesFromDpid = ToSalConversionsUtils.bytesFromDpid(lNodeId); + return new MacAddress(bytesFromDpid); + } + + public static Tables toADTables(final Short tables) { + return new Tables(tables.byteValue()); + } + + public static Capabilities toADCapabiliities(final List> capabilities) { + + int b = 0; + for (Class capability : capabilities) { + if (capability.equals(FlowFeatureCapabilityFlowStats.class)) { + b = Capabilities.CapabilitiesType.FLOW_STATS_CAPABILITY.getValue() | b; + } else if (capability.equals(FlowFeatureCapabilityTableStats.class)) { + b = Capabilities.CapabilitiesType.TABLE_STATS_CAPABILITY.getValue() | b; + } else if (capability.equals(FlowFeatureCapabilityPortStats.class)) { + b = Capabilities.CapabilitiesType.PORT_STATS_CAPABILITY.getValue() | b; + } else if (capability.equals(FlowFeatureCapabilityStp.class)) { + b = Capabilities.CapabilitiesType.STP_CAPABILITY.getValue() | b; + } else if (capability.equals(FlowFeatureCapabilityIpReasm.class)) { + b = Capabilities.CapabilitiesType.IP_REASSEM_CAPABILITY.getValue() | b; + } else if (capability.equals(FlowFeatureCapabilityQueueStats.class)) { + b = Capabilities.CapabilitiesType.QUEUE_STATS_CAPABILITY.getValue() | b; + } else if (capability.equals(FlowFeatureCapabilityArpMatchIp.class)) { + b = Capabilities.CapabilitiesType.ARP_MATCH_IP_CAPABILITY.getValue() | b; + } + } + return new Capabilities(b); + } + + public static Buffers toADBuffers(final Long buffers) { + return new Buffers(buffers.intValue()); + } +} diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.xtend b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.xtend deleted file mode 100644 index debcbac2eb..0000000000 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.xtend +++ /dev/null @@ -1,364 +0,0 @@ -/* - * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.controller.sal.compatibility - -import org.opendaylight.controller.sal.core.Node -import org.opendaylight.controller.sal.core.NodeConnector -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem - -import static com.google.common.base.Preconditions.*; -import static extension org.opendaylight.controller.sal.common.util.Arguments.*; -import static extension org.opendaylight.controller.sal.compatibility.ToSalConversionsUtils.*; - -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey -import org.opendaylight.controller.sal.core.ConstructionException -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortFeatures -import org.opendaylight.controller.sal.core.Bandwidth -import org.opendaylight.controller.sal.core.AdvertisedBandwidth -import org.opendaylight.controller.sal.core.SupportedBandwidth -import org.opendaylight.controller.sal.core.PeerBandwidth -import org.opendaylight.controller.sal.core.Name -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortConfig -import org.opendaylight.controller.sal.core.Config -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.flow.capable.port.State -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated -import java.util.HashSet -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated -import org.opendaylight.controller.sal.core.Tables -import java.util.List -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FeatureCapability -import org.opendaylight.controller.sal.core.Buffers -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityFlowStats -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityTableStats -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityIpReasm -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityPortStats -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityStp -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityQueueStats -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityArpMatchIp -import org.opendaylight.controller.sal.core.Capabilities -import org.opendaylight.controller.sal.core.MacAddress -import java.util.Date -import org.opendaylight.controller.sal.core.TimeStamp -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowNodeConnector -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowNode -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector - -public class NodeMapping { - - public static val MD_SAL_TYPE = "MD_SAL"; - private static val NODE_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; - private static val NODECONNECTOR_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node. - NodeConnector; - - private new() { - throw new UnsupportedOperationException("Utility class. Instantiation is not allowed."); - } - - public static def toADNode(InstanceIdentifier node) throws ConstructionException { - return node.toNodeId.toADNode - } - - public static def toADNode(NodeId id) { - return new Node(MD_SAL_TYPE, id.toADNodeId); - } - - public static def toNodeId(InstanceIdentifier node) { - checkNotNull(node); - checkNotNull(node.getPath()); - checkArgument(node.getPath().size() >= 2); - val arg = node.getPath().get(1); - val item = arg.checkInstanceOf(IdentifiableItem); - val nodeKey = item.getKey().checkInstanceOf(NodeKey); - return nodeKey.id - } - - public static def toADNodeId(NodeId nodeId) { - checkNotNull(nodeId); - return nodeId.value - } - - public static def toADNodeConnector(NodeConnectorRef source) throws ConstructionException { - checkNotNull(source); - val InstanceIdentifier path = checkNotNull(source.getValue()); - checkArgument(path.path.size() >= 3); - val arg = path.getPath().get(2); - val item = arg.checkInstanceOf(IdentifiableItem); - val connectorKey = item.getKey().checkInstanceOf(NodeConnectorKey); - return connectorKey.id.toADNodeConnector(path.toNodeId) - } - - public static def toADNodeConnector(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId ncid, - org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId nid) { - return new NodeConnector(ncid.toNodeConnectorType(nid), - ncid.toADNodeConnectorId(nid), nid.toADNode); - } - - public static def toNodeConnectorType(NodeConnectorId ncId, NodeId nodeId) { - if (ncId.equals(nodeId.toLocalNodeConnectorId)) { - return NodeConnector.NodeConnectorIDType.SWSTACK - } else if (ncId.equals(nodeId.toNormalNodeConnectorId)) { - return NodeConnector.NodeConnectorIDType.HWPATH - } else if (ncId.equals(nodeId.toControllerNodeConnectorId)) { - return NodeConnector.NodeConnectorIDType.CONTROLLER - } - return MD_SAL_TYPE - } - - public static def toADNodeConnectorId(NodeConnectorId nodeConnectorId, NodeId nodeId) { - if (nodeConnectorId.equals(nodeId.toLocalNodeConnectorId) || - nodeConnectorId.equals(nodeId.toNormalNodeConnectorId) || - nodeConnectorId.equals(nodeId.toControllerNodeConnectorId)) { - return NodeConnector.SPECIALNODECONNECTORID - } - return nodeConnectorId.value - } - - public static def toControllerNodeConnectorId(NodeId node) { - return new NodeConnectorId(node.value + ":" + 4294967293L) - } - - public static def toLocalNodeConnectorId(NodeId node) { - return new NodeConnectorId(node.value + ":" + 4294967294L) - } - - public static def toNormalNodeConnectorId(NodeId node) { - return new NodeConnectorId(node.value + ":" + 4294967290L) - } - - public static def toNodeRef(Node node) { - checkArgument(MD_SAL_TYPE.equals(node.getType())); - var nodeId = node.ID.checkInstanceOf(String) - val nodeKey = new NodeKey(new NodeId(nodeId)); - val nodePath = InstanceIdentifier.builder().node(Nodes).child(NODE_CLASS, nodeKey).toInstance(); - return new NodeRef(nodePath); - } - - public static def toNodeConnectorRef(NodeConnector nodeConnector) { - val node = nodeConnector.node.toNodeRef(); - val nodePath = node.getValue() as InstanceIdentifier - var NodeConnectorId nodeConnectorId - if (nodeConnector.ID.equals(NodeConnector.SPECIALNODECONNECTORID)) { - if (nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.SWSTACK)) { - nodeConnectorId = nodePath.toNodeId.toLocalNodeConnectorId - } else if (nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.HWPATH)) { - nodeConnectorId = nodePath.toNodeId.toNormalNodeConnectorId - } else if (nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.CONTROLLER)) { - nodeConnectorId = nodePath.toNodeId.toControllerNodeConnectorId - } - } else { - nodeConnectorId = new NodeConnectorId(nodeConnector.ID.checkInstanceOf(String)) - } - val connectorKey = new NodeConnectorKey(nodeConnectorId); - val path = InstanceIdentifier.builder(nodePath).child(NODECONNECTOR_CLASS, connectorKey).toInstance(); - return new NodeConnectorRef(path); - } - - public static def toADNode(NodeRef node) throws ConstructionException { - return toADNode(node.getValue()); - } - - public static def toADNodeConnectorProperties(NodeConnectorUpdated nc) { - val fcncu = nc.getAugmentation(FlowCapableNodeConnectorUpdated) - if (fcncu != null) { - return fcncu.toADNodeConnectorProperties - } - return new HashSet(); - } - - public static def toADNodeConnectorProperties(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc) { - val fcnc = nc.getAugmentation(FlowCapableNodeConnector) - if (fcnc != null) { - return fcnc.toADNodeConnectorProperties - } - return new HashSet(); - } - - public static def toADNodeConnectorProperties(FlowNodeConnector fcncu) { - val props = new HashSet(); - if (fcncu != null) { - if (fcncu.currentFeature != null && fcncu.currentFeature.toAdBandwidth != null) { - props.add(fcncu.currentFeature.toAdBandwidth) - } - if (fcncu.advertisedFeatures != null && fcncu.advertisedFeatures.toAdAdvertizedBandwidth != null) { - props.add(fcncu.advertisedFeatures.toAdAdvertizedBandwidth) - } - if (fcncu.supported != null && fcncu.supported.toAdSupportedBandwidth != null) { - props.add(fcncu.supported.toAdSupportedBandwidth) - } - if (fcncu.peerFeatures != null && fcncu.peerFeatures.toAdPeerBandwidth != null) { - props.add(fcncu.peerFeatures.toAdPeerBandwidth) - } - if (fcncu.name != null && fcncu.name.toAdName != null) { - props.add(fcncu.name.toAdName) - } - if (fcncu.configuration != null && fcncu.configuration.toAdConfig != null) { - props.add(fcncu.configuration.toAdConfig) - } - if (fcncu.state != null && fcncu.state.toAdState != null) { - props.add(fcncu.state.toAdState) - } - } - return props - } - - public static def toAdName(String name) { - return new Name(name) - } - - public static def toAdConfig(PortConfig pc) { - var Config config; - if (pc.PORTDOWN) { - config = new Config(Config.ADMIN_DOWN) - } else { - config = new Config(Config.ADMIN_UP) - } - return config - } - - public static def toAdState(State s) { - var org.opendaylight.controller.sal.core.State state - if (s.linkDown) { - state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_DOWN) - } else { - state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_UP) - } - return state - } - - public static def toAdBandwidth(PortFeatures pf) { - var Bandwidth bw = null - if (pf.isTenMbHd || pf.isTenMbFd) { - bw = new Bandwidth(Bandwidth.BW10Mbps) - } else if (pf.isHundredMbHd || pf.isHundredMbFd) { - bw = new Bandwidth(Bandwidth.BW100Mbps) - } else if (pf.isOneGbHd || pf.isOneGbFd) { - bw = new Bandwidth(Bandwidth.BW1Gbps) - } else if (pf.isOneGbFd) { - bw = new Bandwidth(Bandwidth.BW10Gbps) - } else if (pf.isTenGbFd) { - bw = new Bandwidth(Bandwidth.BW10Gbps) - } else if (pf.isFortyGbFd) { - bw = new Bandwidth(Bandwidth.BW40Gbps) - } else if (pf.isHundredGbFd) { - bw = new Bandwidth(Bandwidth.BW100Gbps) - } else if (pf.isOneTbFd) { - bw = new Bandwidth(Bandwidth.BW1Tbps) - } - return bw; - } - - public static def toAdAdvertizedBandwidth(PortFeatures pf) { - var AdvertisedBandwidth abw - val bw = pf.toAdBandwidth - if (bw != null) { - abw = new AdvertisedBandwidth(bw.value) - } - return abw - } - - public static def toAdSupportedBandwidth(PortFeatures pf) { - var SupportedBandwidth sbw - val bw = pf.toAdBandwidth - if (bw != null) { - sbw = new SupportedBandwidth(bw.value) - } - return sbw - } - - public static def toAdPeerBandwidth(PortFeatures pf) { - var PeerBandwidth pbw - val bw = pf.toAdBandwidth - if (bw != null) { - pbw = new PeerBandwidth(bw.value) - } - return pbw - } - - public static def toADNodeProperties(NodeUpdated nu) { - val fcnu = nu.getAugmentation(FlowCapableNodeUpdated) - if (fcnu != null) { - return fcnu.toADNodeProperties(nu.id) - } - return new HashSet(); - - } - - public static def toADNodeProperties(FlowNode fcnu, NodeId id) { - val props = new HashSet(); - if (fcnu != null) { - props.add(toADTimestamp) - - // props.add(fcnu.supportedActions.toADActions) - TODO - if (id != null) { - props.add(id.toADMacAddress) - } - if (fcnu.switchFeatures != null) { - if (fcnu.switchFeatures.maxTables != null) { - props.add(fcnu.switchFeatures.maxTables.toADTables) - } - if (fcnu.switchFeatures.capabilities != null) { - props.add(fcnu.switchFeatures.capabilities.toADCapabiliities) - } - if (fcnu.switchFeatures.maxBuffers != null) { - props.add(fcnu.switchFeatures.maxBuffers.toADBuffers) - } - } - } - return props; - } - - public static def toADTimestamp() { - val date = new Date(); - val timestamp = new TimeStamp(date.time, "connectedSince") - return timestamp; - } - - public static def toADMacAddress(NodeId id) { - return new MacAddress(Long.parseLong(id.value.replaceAll("openflow:", "")).longValue.bytesFromDpid) - } - - public static def toADTables(Short tables) { - return new Tables(tables.byteValue) - } - - public static def toADCapabiliities(List> capabilities) { - var int b - for (capability : capabilities) { - if (capability.equals(FlowFeatureCapabilityFlowStats)) { - b = Capabilities.CapabilitiesType.FLOW_STATS_CAPABILITY.value.bitwiseOr(b) - } else if (capability.equals(FlowFeatureCapabilityTableStats)) { - b = Capabilities.CapabilitiesType.TABLE_STATS_CAPABILITY.value.bitwiseOr(b) - } else if (capability.equals(FlowFeatureCapabilityPortStats)) { - b = Capabilities.CapabilitiesType.PORT_STATS_CAPABILITY.value.bitwiseOr(b) - } else if (capability.equals(FlowFeatureCapabilityStp)) { - b = Capabilities.CapabilitiesType.STP_CAPABILITY.value.bitwiseOr(b) - } else if (capability.equals(FlowFeatureCapabilityIpReasm)) { - b = Capabilities.CapabilitiesType.IP_REASSEM_CAPABILITY.value.bitwiseOr(b) - } else if (capability.equals(FlowFeatureCapabilityQueueStats)) { - b = Capabilities.CapabilitiesType.QUEUE_STATS_CAPABILITY.value.bitwiseOr(b) - } else if (capability.equals(FlowFeatureCapabilityArpMatchIp)) { - b = Capabilities.CapabilitiesType.ARP_MATCH_IP_CAPABILITY.value.bitwiseOr(b) - } - } - return new Capabilities(b) - } - - public static def toADBuffers(Long buffers) { - return new Buffers(buffers.intValue) - } - -}