56eeed40b053e29d2b2038af35d390f23f95070d
[ovsdb.git] / southbound / southbound-impl / src / main / java / org / opendaylight / ovsdb / southbound / ovsdb / transact / TerminationPointCreateCommand.java
1 /*
2  * Copyright (c) 2015, 2016 Brocade Communications Systems, Inc. and others.  All rights reserved.
3  *
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
7  */
8 package org.opendaylight.ovsdb.southbound.ovsdb.transact;
9
10 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
11 import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
12
13 import java.util.Collection;
14 import java.util.Collections;
15 import java.util.HashMap;
16 import java.util.HashSet;
17 import java.util.List;
18 import java.util.Map;
19 import java.util.Map.Entry;
20 import java.util.concurrent.ExecutionException;
21 import java.util.Set;
22
23 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
24 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
25 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
26 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
27 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
28 import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
29 import org.opendaylight.ovsdb.lib.notation.Mutator;
30 import org.opendaylight.ovsdb.lib.notation.UUID;
31 import org.opendaylight.ovsdb.lib.operations.Mutate;
32 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
33 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
34 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
35 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
36 import org.opendaylight.ovsdb.schema.openvswitch.Port;
37 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
38 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
39 import org.opendaylight.ovsdb.southbound.SouthboundProvider;
40 import org.opendaylight.ovsdb.utils.yang.YangUtils;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
55 import org.opendaylight.yangtools.yang.binding.DataObject;
56 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
57 import org.slf4j.Logger;
58 import org.slf4j.LoggerFactory;
59
60 import com.google.common.base.Optional;
61 import com.google.common.collect.Sets;
62 import com.google.common.util.concurrent.CheckedFuture;
63
64 public class TerminationPointCreateCommand implements TransactCommand {
65
66     private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCreateCommand.class);
67
68     @Override
69     public void execute(TransactionBuilder transaction, BridgeOperationalState state,
70                         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> events) {
71         execute(transaction, state, TransactUtils.extractCreated(events, OvsdbTerminationPointAugmentation.class),
72                 TransactUtils.extractCreatedOrUpdated(events, Node.class));
73     }
74
75     @Override
76     public void execute(TransactionBuilder transaction, BridgeOperationalState state,
77                         Collection<DataTreeModification<Node>> modifications) {
78         execute(transaction, state, TransactUtils.extractCreated(modifications, OvsdbTerminationPointAugmentation.class),
79                 TransactUtils.extractCreatedOrUpdated(modifications, Node.class));
80     }
81
82     private void execute(TransactionBuilder transaction, BridgeOperationalState state,
83                          Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
84                                  OvsdbTerminationPointAugmentation>
85                                  createdTerminationPoints, Map<InstanceIdentifier<Node>, Node> nodes) {
86         for (Entry<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> entry :
87                 createdTerminationPoints.entrySet()) {
88             OvsdbTerminationPointAugmentation terminationPoint = entry.getValue();
89             LOG.debug("Received request to create termination point {}",
90                     terminationPoint.getName());
91             InstanceIdentifier terminationPointIid = entry.getKey();
92             Optional<TerminationPoint> terminationPointOptional =
93                     state.getBridgeTerminationPoint(terminationPointIid);
94             if (!terminationPointOptional.isPresent()) {
95                 // Configure interface
96                 String interfaceUuid = "Interface_" + SouthboundMapper.getRandomUUID();
97                 Interface ovsInterface =
98                         TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Interface.class);
99                 createInterface(terminationPoint, ovsInterface);
100                 transaction.add(op.insert(ovsInterface).withId(interfaceUuid));
101
102                 stampInstanceIdentifier(transaction, entry.getKey(), ovsInterface.getName());
103
104                 // Configure port with the above interface details
105                 String portUuid = "Port_" + SouthboundMapper.getRandomUUID();
106                 Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
107                 createPort(terminationPoint, port, interfaceUuid);
108                 transaction.add(op.insert(port).withId(portUuid));
109
110                 //Configure bridge with the above port details
111                 Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class);
112                 if (getBridge(entry.getKey(), nodes) != null) {
113                     bridge.setName(getBridge(entry.getKey(), nodes).getBridgeName().getValue());
114                     bridge.setPorts(Sets.newHashSet(new UUID(portUuid)));
115
116                     transaction.add(op.mutate(bridge)
117                             .addMutation(bridge.getPortsColumn().getSchema(),
118                                     Mutator.INSERT, bridge.getPortsColumn().getData())
119                             .where(bridge.getNameColumn().getSchema()
120                                     .opEqual(bridge.getNameColumn().getData())).build());
121                 }
122             }
123         }
124
125     }
126
127     private void createInterface(
128             final OvsdbTerminationPointAugmentation terminationPoint,
129             final Interface ovsInterface) {
130         ovsInterface.setName(terminationPoint.getName());
131
132         createInterfaceType(terminationPoint, ovsInterface);
133         createOfPort(terminationPoint, ovsInterface);
134         createOfPortRequest(terminationPoint, ovsInterface);
135         createInterfaceOptions(terminationPoint, ovsInterface);
136         createInterfaceOtherConfig(terminationPoint, ovsInterface);
137         createInterfaceExternalIds(terminationPoint, ovsInterface);
138         createInterfaceLldp(terminationPoint, ovsInterface);
139         createInterfaceBfd(terminationPoint, ovsInterface);
140     }
141
142     private void createInterfaceType(final OvsdbTerminationPointAugmentation terminationPoint,
143                                      final Interface ovsInterface) {
144
145         Class<? extends InterfaceTypeBase> mdsaltype = terminationPoint.getInterfaceType();
146         if (mdsaltype != null) {
147             ovsInterface.setType(SouthboundMapper.createOvsdbInterfaceType(mdsaltype));
148         }
149     }
150
151     private void createPort(
152             final OvsdbTerminationPointAugmentation terminationPoint,
153             final Port port, final String interfaceUuid) {
154
155         port.setName(terminationPoint.getName());
156         port.setInterfaces(Sets.newHashSet(new UUID(interfaceUuid)));
157         createPortOtherConfig(terminationPoint, port);
158         createPortVlanTag(terminationPoint, port);
159         createPortVlanTrunk(terminationPoint, port);
160         createPortVlanMode(terminationPoint, port);
161         createPortExternalIds(terminationPoint, port);
162     }
163
164     private void createOfPort(
165             final OvsdbTerminationPointAugmentation terminationPoint,
166             final Interface ovsInterface) {
167
168         Long ofPort = terminationPoint.getOfport();
169         if (ofPort != null) {
170             ovsInterface.setOpenFlowPort(Sets.newHashSet(ofPort));
171         }
172     }
173
174     private void createOfPortRequest(
175             final OvsdbTerminationPointAugmentation terminationPoint,
176             final Interface ovsInterface) {
177
178         Integer ofPortRequest = terminationPoint.getOfportRequest();
179         if (ofPortRequest != null) {
180             ovsInterface.setOpenFlowPortRequest(Sets.newHashSet(ofPortRequest.longValue()));
181         }
182     }
183
184     private void createInterfaceOptions(
185             final OvsdbTerminationPointAugmentation terminationPoint,
186             final Interface ovsInterface) {
187
188         //Configure optional input
189         if (terminationPoint.getOptions() != null) {
190             try {
191                 ovsInterface.setOptions(YangUtils.convertYangKeyValueListToMap(terminationPoint.getOptions(),
192                         Options::getOption, Options::getValue));
193             } catch (NullPointerException e) {
194                 LOG.warn("Incomplete OVSDB interface options", e);
195             }
196         }
197     }
198
199     private void createInterfaceExternalIds(
200             final OvsdbTerminationPointAugmentation terminationPoint,
201             final Interface ovsInterface) {
202
203         List<InterfaceExternalIds> interfaceExternalIds =
204                 terminationPoint.getInterfaceExternalIds();
205         if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
206             try {
207                 ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
208                         InterfaceExternalIds::getExternalIdKey, InterfaceExternalIds::getExternalIdValue));
209             } catch (NullPointerException e) {
210                 LOG.warn("Incomplete OVSDB interface external_ids", e);
211             }
212         }
213     }
214
215     private void createInterfaceOtherConfig(
216             final OvsdbTerminationPointAugmentation terminationPoint,
217             final Interface ovsInterface) {
218
219         List<InterfaceOtherConfigs> interfaceOtherConfigs =
220                 terminationPoint.getInterfaceOtherConfigs();
221         if (interfaceOtherConfigs != null && !interfaceOtherConfigs.isEmpty()) {
222             Map<String, String> otherConfigsMap = new HashMap<>();
223             for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs) {
224                 otherConfigsMap.put(interfaceOtherConfig.getOtherConfigKey(),
225                         interfaceOtherConfig.getOtherConfigValue());
226             }
227             try {
228                 ovsInterface.setOtherConfig(otherConfigsMap);
229             } catch (NullPointerException e) {
230                 LOG.warn("Incomplete OVSDB interface other_config", e);
231             }
232         }
233     }
234
235     private void createInterfaceLldp(
236             final OvsdbTerminationPointAugmentation terminationPoint,
237             final Interface ovsInterface) {
238
239         try {
240             List<InterfaceLldp> interfaceLldpList =
241                     terminationPoint.getInterfaceLldp();
242             if (interfaceLldpList != null && !interfaceLldpList.isEmpty()) {
243                 try {
244                     ovsInterface.setLldp(YangUtils.convertYangKeyValueListToMap(interfaceLldpList,
245                             InterfaceLldp::getLldpKey, InterfaceLldp::getLldpValue));
246                 } catch (NullPointerException e) {
247                     LOG.warn("Incomplete OVSDB interface lldp", e);
248                 }
249             }
250         } catch (SchemaVersionMismatchException e) {
251             schemaMismatchLog("lldp", "Interface", e);
252         }
253     }
254
255     private void createInterfaceBfd(final OvsdbTerminationPointAugmentation terminationPoint,
256                     final Interface ovsInterface) {
257
258         try {
259             List<InterfaceBfd> interfaceBfdList = terminationPoint.getInterfaceBfd();
260             if (interfaceBfdList != null && !interfaceBfdList.isEmpty()) {
261                 try {
262                     ovsInterface.setBfd(YangUtils.convertYangKeyValueListToMap(interfaceBfdList,
263                                     InterfaceBfd::getBfdKey, InterfaceBfd::getBfdValue));
264                 } catch (NullPointerException e) {
265                     LOG.warn("Incomplete OVSDB interface bfd", e);
266                 }
267             }
268         } catch (SchemaVersionMismatchException e) {
269             schemaMismatchLog("bfd", "Interface", e);
270         }
271     }
272
273     private void createPortExternalIds(
274             final OvsdbTerminationPointAugmentation terminationPoint,
275             final Port port) {
276
277         List<PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
278         if (portExternalIds != null && !portExternalIds.isEmpty()) {
279             try {
280                 port.setExternalIds(YangUtils.convertYangKeyValueListToMap(portExternalIds,
281                         PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue));
282             } catch (NullPointerException e) {
283                 LOG.warn("Incomplete OVSDB port external_ids", e);
284             }
285         }
286     }
287
288     private void createPortVlanTag(
289             final OvsdbTerminationPointAugmentation terminationPoint,
290             final Port port) {
291
292         if (terminationPoint.getVlanTag() != null) {
293             Set<Long> vlanTag = new HashSet<>();
294             vlanTag.add(terminationPoint.getVlanTag().getValue().longValue());
295             port.setTag(vlanTag);
296         }
297     }
298
299     private void createPortVlanTrunk(
300             final OvsdbTerminationPointAugmentation terminationPoint,
301             final Port port) {
302
303         if (terminationPoint.getTrunks() != null && terminationPoint.getTrunks().size() > 0) {
304             Set<Long> portTrunks = new HashSet<>();
305             List<Trunks> modelTrunks = terminationPoint.getTrunks();
306             for (Trunks trunk: modelTrunks) {
307                 if (trunk.getTrunk() != null) {
308                     portTrunks.add(trunk.getTrunk().getValue().longValue());
309                 }
310             }
311             port.setTrunks(portTrunks);
312         }
313     }
314
315     private void createPortVlanMode(
316             final OvsdbTerminationPointAugmentation terminationPoint,
317             final Port port) {
318         if (terminationPoint.getVlanMode() != null) {
319             Set<String> portVlanMode = new HashSet<>();
320             VlanMode modelVlanMode = terminationPoint.getVlanMode();
321             portVlanMode.add(SouthboundConstants.VLANMODES.values()[modelVlanMode.getIntValue() - 1].getMode());
322             port.setVlanMode(portVlanMode);
323         }
324     }
325
326     private void createPortOtherConfig(
327             final OvsdbTerminationPointAugmentation terminationPoint,
328             final Port ovsPort) {
329         List<PortOtherConfigs> portOtherConfigs =
330                 terminationPoint.getPortOtherConfigs();
331         if (portOtherConfigs != null && !portOtherConfigs.isEmpty()) {
332             try {
333                 ovsPort.setOtherConfig(YangUtils.convertYangKeyValueListToMap(portOtherConfigs,
334                         PortOtherConfigs::getOtherConfigKey, PortOtherConfigs::getOtherConfigValue));
335             } catch (NullPointerException e) {
336                 LOG.warn("Incomplete OVSDB port other_config", e);
337             }
338         }
339     }
340
341     private OvsdbBridgeAugmentation getBridge(InstanceIdentifier<?> key, Map<InstanceIdentifier<Node>, Node> nodes) {
342         OvsdbBridgeAugmentation bridge = null;
343         InstanceIdentifier<Node> nodeIid = key.firstIdentifierOf(Node.class);
344         if (nodes != null && nodes.get(nodeIid) != null) {
345             Node node = nodes.get(nodeIid);
346             bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
347             if (bridge == null) {
348                 ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction();
349                 CheckedFuture<Optional<Node>, ReadFailedException> future =
350                         transaction.read(LogicalDatastoreType.OPERATIONAL, nodeIid);
351                 try {
352                     Optional<Node> nodeOptional = future.get();
353                     if (nodeOptional.isPresent()) {
354                         bridge = nodeOptional.get().getAugmentation(OvsdbBridgeAugmentation.class);
355                     }
356                 } catch (InterruptedException | ExecutionException e) {
357                     LOG.warn("Error reading from datastore",e);
358                 }
359                 transaction.close();
360             }
361         }
362         return bridge;
363     }
364
365     public static void stampInstanceIdentifier(TransactionBuilder transaction, InstanceIdentifier
366             <OvsdbTerminationPointAugmentation> iid, String interfaceName) {
367         Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
368         port.setName(interfaceName);
369         port.setExternalIds(Collections.<String,String>emptyMap());
370         Mutate mutate = TransactUtils.stampInstanceIdentifierMutation(transaction,
371                 iid,
372                 port.getSchema(),
373                 port.getExternalIdsColumn().getSchema());
374         transaction.add(mutate
375                 .where(port.getNameColumn().getSchema().opEqual(interfaceName))
376                 .build());
377     }
378
379 }