2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
11 import static com.google.common.base.Preconditions.checkNotNull;
12 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.EndpointHelper.lookupEndpoint;
13 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.EndpointHelper.updateEndpointRemoveLocation;
14 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.EndpointHelper.updateEndpointWithLocation;
15 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper.checkOfOverlayConfig;
16 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper.getInventoryNodeConnectorIdString;
17 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper.getInventoryNodeIdString;
18 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper.removeTunnelsOfOverlayConfig;
19 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper.updateOfOverlayConfig;
20 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.NeutronHelper.getEpKeyFromNeutronMapper;
21 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.createTunnelPort;
22 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getManagerNode;
23 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getOvsdbBridgeFromTerminationPoint;
24 import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getTopologyNode;
26 import java.util.ArrayList;
27 import java.util.Collection;
28 import java.util.Collections;
29 import java.util.HashMap;
30 import java.util.List;
33 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
34 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
35 import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
36 import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
37 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
38 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
39 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
40 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
41 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
52 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
56 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
57 import org.opendaylight.yangtools.concepts.ListenerRegistration;
58 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
59 import org.slf4j.Logger;
60 import org.slf4j.LoggerFactory;
62 public class TerminationPointDataChangeListener implements DataTreeChangeListener<OvsdbTerminationPointAugmentation>,
65 private static final String NEUTRON_EXTERNAL_ID_KEY = "iface-id";
66 private final ListenerRegistration<?> registration;
67 private final DataBroker dataBroker;
68 private final EndpointService epService;
69 private static final Logger LOG = LoggerFactory.getLogger(TerminationPointDataChangeListener.class);
70 private final List<AbstractTunnelType> requiredTunnelTypes;
72 public TerminationPointDataChangeListener(DataBroker dataBroker, EndpointService epService) {
73 this.dataBroker = checkNotNull(dataBroker);
74 this.epService = checkNotNull(epService);
75 InstanceIdentifier<OvsdbTerminationPointAugmentation> iid = InstanceIdentifier.create(NetworkTopology.class)
76 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
78 .child(TerminationPoint.class)
79 .augmentation(OvsdbTerminationPointAugmentation.class);
80 registration = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(
81 LogicalDatastoreType.OPERATIONAL, iid), this);
82 requiredTunnelTypes = createSupportedTunnelsList();
85 private List<AbstractTunnelType> createSupportedTunnelsList() {
86 List<AbstractTunnelType> required = new ArrayList<>();
87 required.add(new VxlanTunnelType());
88 required.add(new VxlanGpeTunnelType());
89 return Collections.unmodifiableList(required);
93 public void close() throws Exception {
98 * When vSwitch is deleted, we loose data in operational DS to determine Iid of
99 * corresponding NodeId.
101 private static final Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, NodeId> NODE_ID_BY_TERMIN_POINT =
105 public void onDataTreeChanged(Collection<DataTreeModification<OvsdbTerminationPointAugmentation>> changes) {
106 for (DataTreeModification<OvsdbTerminationPointAugmentation> change: changes) {
107 DataObjectModification<OvsdbTerminationPointAugmentation> rootNode = change.getRootNode();
108 InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid = change.getRootPath().getRootIdentifier();
109 OvsdbTerminationPointAugmentation origOvsdbTp = rootNode.getDataBefore();
110 switch (rootNode.getModificationType()) {
111 case SUBTREE_MODIFIED:
113 OvsdbTerminationPointAugmentation updatedOvsdbTp = rootNode.getDataAfter();
114 OvsdbBridgeAugmentation ovsdbBridge = getOvsdbBridgeFromTerminationPoint(ovsdbTpIid, dataBroker);
115 if (origOvsdbTp == null) {
116 NODE_ID_BY_TERMIN_POINT.put(ovsdbTpIid,
117 new NodeId(getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker)));
120 processOvsdbBridge(ovsdbBridge, updatedOvsdbTp, ovsdbTpIid);
123 processRemovedTp(NODE_ID_BY_TERMIN_POINT.get(ovsdbTpIid), origOvsdbTp, ovsdbTpIid);
131 private void processOvsdbBridge(OvsdbBridgeAugmentation ovsdbBridge, OvsdbTerminationPointAugmentation ovsdbTp,
132 InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid) {
134 checkNotNull(ovsdbBridge);
135 if (ovsdbBridge.getBridgeName().getValue().equals(ovsdbTp.getName())) {
136 LOG.debug("Termination Point {} same as Bridge {}. Not processing", ovsdbTp.getName(),
137 ovsdbBridge.getBridgeName().getValue());
141 String nodeIdString = getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker);
142 if (nodeIdString == null) {
143 LOG.debug("nodeIdString for TerminationPoint {} was null", ovsdbTp);
146 String nodeConnectorIdString = getInventoryNodeConnectorIdString(nodeIdString, ovsdbTp, ovsdbTpIid, dataBroker);
147 if (nodeConnectorIdString == null) {
148 LOG.debug("nodeConnectorIdString for TerminationPoint {} was null", ovsdbTp);
152 InstanceIdentifier<Node> nodeIid = ovsdbTpIid.firstIdentifierOf(Node.class);
153 String externalId = getNeutronPortUuid(ovsdbTp);
155 IpAddress hostIp = getIpFromOvsdb(ovsdbBridge);
158 * Ports created by Nova have an external_id field
159 * in them, which is the Neutron port UUID. If a port
160 * has an external_id, get the EndpointKey for the
161 * Neutron port UUID from neutron-mapper, then look
162 * up the Endpoint in the Endpoint Registry using
163 * that key an update it with the location information
164 * (NodeId and NodeConnectorId from the inventory model)
165 * and the port name, constructed using the port UUID.
168 if (externalId != null) {
169 EndpointKey epKey = getEpKeyFromNeutronMapper(new UniqueId(externalId), dataBroker);
171 LOG.debug("TerminationPoint {} with external ID {} is not in Neutron Map", ovsdbTp, externalId);
174 ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
175 ep = lookupEndpoint(epKey, transaction);
177 LOG.warn("TerminationPoint {} with external ID {} is in Neutron Map, "
178 + "but corresponding Endpoint {} isn't in Endpoint Repository", ovsdbTp, externalId, epKey);
182 * Look up the Node in Inventory that corresponds to the
183 * Topology Node that owns this Termination Point (port),
184 * and see if it already is configured with a complete
185 * OfOverlay augmentation. If it hasn't, go see if the
186 * tunnel ports exist, and if not, go and create them.
188 if (!checkOfOverlayConfig(nodeIdString, requiredTunnelTypes, dataBroker)) {
189 checkNotNull(nodeIid);
191 * Check to see if we need to create a
192 * tunnel port on the parent node
194 createTunnelPorts(nodeIid, dataBroker);
197 LOG.debug("TerminationPoint {} had no external ID, not processing for external ID.", ovsdbTp);
202 * This may be a notification for a tunnel we just created.
203 * In that case, we need to update the Inventory Node's OfOverlay
204 * augmentation with missing information
206 AbstractTunnelType tunnel = getTunnelType(ovsdbTp, requiredTunnelTypes);
207 if (tunnel != null) {
208 updateOfOverlayConfig(hostIp, nodeIdString, nodeConnectorIdString, tunnel, dataBroker);
210 if (externalId != null) {
211 ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
212 updateEndpointWithLocation(ep, nodeIdString, nodeConnectorIdString, rwTx);
217 * If removed termination point was a tunnel port,
218 * removes attached tunnels (namely Vxlan-type) from OVSDB bridge,
219 * else removes location info from TP.
221 * @param nodeId {@link NodeId}
222 * @param ovsdbTp {@link OvsdbTerminationPointAugmentation}
223 * @param ovsdbTpIid termination point's IID {@link InstanceIdentifier}
225 private void processRemovedTp(NodeId nodeId, OvsdbTerminationPointAugmentation ovsdbTp,
226 InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid) {
227 if (isTunnelPort(ovsdbTp, requiredTunnelTypes)) {
228 removeTunnelsOfOverlayConfig(nodeId.getValue(), requiredTunnelTypes, dataBroker);
230 deleteLocationForTp(ovsdbTp);
235 * Delete location on EP for given TP.
237 * @param ovsdbTp {@link OvsdbTerminationPointAugmentation}
239 private void deleteLocationForTp(OvsdbTerminationPointAugmentation ovsdbTp) {
240 String externalId = getNeutronPortUuid(ovsdbTp);
241 if (externalId != null) {
242 EndpointKey epKey = getEpKeyFromNeutronMapper(new UniqueId(externalId), dataBroker);
244 LOG.debug("TerminationPoint {} with external ID {} is not in Neutron Map.", ovsdbTp, externalId);
247 ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();
248 Endpoint ep = lookupEndpoint(epKey, readOnlyTransaction);
249 readOnlyTransaction.close();
251 LOG.warn("TerminationPoint {} with external ID {} is in Neutron Map,"
252 + " but corresponding Endpoint {} isn't in Endpoint Repository.", ovsdbTp, externalId, epKey);
255 updateEndpointRemoveLocation(ep, dataBroker.newReadWriteTransaction());
257 LOG.debug("TerminationPoint {} has no external ID, not processing.", ovsdbTp);
262 * Check to see if the {@link OvsdbTerminationPointAugmentation} is also a Tunnel port that we
265 * @param ovsdbTp {@link OvsdbTerminationPointAugmentation}
266 * @param requiredTunnelTypes {@link List} of tunnel types
268 private static AbstractTunnelType getTunnelType(OvsdbTerminationPointAugmentation ovsdbTp,
269 List<AbstractTunnelType> requiredTunnelTypes) {
270 if (ovsdbTp.getInterfaceType() != null) {
271 for (AbstractTunnelType tunnelType : requiredTunnelTypes) {
272 if (tunnelType.isValidTunnelPort(ovsdbTp)) {
281 * Check to see if the {@link OvsdbTerminationPointAugmentation}
282 * is also a Tunnel port that we care about.
284 * @param ovsdbTp {@link OvsdbTerminationPointAugmentation}
286 * @param requiredTunnelTypes {@link List} of tunnel types
288 * @return true if it's a required tunnel port, false if it isn't
290 private boolean isTunnelPort(OvsdbTerminationPointAugmentation ovsdbTp,
291 List<AbstractTunnelType> requiredTunnelTypes) {
292 if (ovsdbTp.getInterfaceType() != null) {
293 for (AbstractTunnelType tunnelType : requiredTunnelTypes) {
294 if (tunnelType.isValidTunnelPort(ovsdbTp)) {
303 * Get the Neutron Port UUID from an {@link OvsdbTerminationPointAugmentation}.
304 * The Neutron Port UUID is stored as an "external-id" in the termination point.
306 * @param ovsdbTp The {@link OvsdbTerminationPointAugmentation}
307 * @return The String representation of the Neutron Port UUID, null if not present
309 private String getNeutronPortUuid(OvsdbTerminationPointAugmentation ovsdbTp) {
310 if (ovsdbTp.getInterfaceExternalIds() == null) {
313 for (InterfaceExternalIds id : ovsdbTp.getInterfaceExternalIds()) {
314 if (id.getExternalIdKey() != null && id.getExternalIdKey().equals(NEUTRON_EXTERNAL_ID_KEY)) {
316 if (id.getExternalIdValue() != null) {
317 return id.getExternalIdValue();
325 * Check to see if all tunnel ports are present, and if not,
328 * @param nodeIid {@link InstanceIdentifier}
329 * @param dataBroker {@link DataBroker}
331 private void createTunnelPorts(InstanceIdentifier<Node> nodeIid, DataBroker dataBroker) {
333 Node node = getTopologyNode(nodeIid, dataBroker);
336 if (node.getAugmentation(OvsdbBridgeAugmentation.class) == null) {
337 LOG.trace("Node {} is not an OVSDB manageable node", nodeIid);
342 * See if this Topology Node has the required tunnel ports,
343 * and if not, go and create them
345 for (AbstractTunnelType tunnelType : requiredTunnelTypes) {
346 boolean tunnelPresent = false;
347 for (TerminationPoint tp : node.getTerminationPoint()) {
348 OvsdbTerminationPointAugmentation tpAug = tp.getAugmentation(OvsdbTerminationPointAugmentation.class);
352 if (tunnelType.isValidTunnelPort(tpAug)) {
353 tunnelPresent = true;
357 if (!tunnelPresent) {
358 createTunnelPort(nodeIid, node, tunnelType, dataBroker);
364 * Get the IP address of the host that owns the {@link OvsdbBridgeAugmentation}.
366 * @param ovsdbBridge The OVSDB bridge node
367 * @return The IP address of the host that the bridge is on
369 private IpAddress getIpFromOvsdb(OvsdbBridgeAugmentation ovsdbBridge) {
371 * The manager Node referenced by this node has the
374 OvsdbNodeAugmentation managerNode = getManagerNode(ovsdbBridge, dataBroker);
376 if (managerNode == null) {
380 if (managerNode.getConnectionInfo() != null) {
381 return managerNode.getConnectionInfo().getRemoteIp();