/*
- * Copyright (c) 2015 Brocade Communications Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2015, 2016 Brocade Communications 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,
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
+import com.google.common.util.concurrent.CheckedFuture;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.concurrent.ExecutionException;
import java.util.Set;
-
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.Mutate;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundProvider;
+import org.opendaylight.ovsdb.utils.yang.YangUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
-
-public class TerminationPointCreateCommand extends AbstractTransactCommand {
+public class TerminationPointCreateCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCreateCommand.class);
- public TerminationPointCreateCommand(BridgeOperationalState state,
- AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
- super(state, changes);
+ @Override
+ public void execute(TransactionBuilder transaction, BridgeOperationalState state,
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> events) {
+ execute(transaction, state, TransactUtils.extractCreated(events, OvsdbTerminationPointAugmentation.class),
+ TransactUtils.extractCreatedOrUpdated(events, Node.class));
}
@Override
- public void execute(TransactionBuilder transaction) {
- for (Entry<InstanceIdentifier<?>, DataObject> entry: getChanges().getCreatedData().entrySet()) {
- DataObject dataObject = entry.getValue();
- if (dataObject instanceof OvsdbTerminationPointAugmentation) {
- OvsdbTerminationPointAugmentation terminationPoint = (OvsdbTerminationPointAugmentation) dataObject;
- LOG.debug("Received request to create termination point {}",
- terminationPoint.getName());
- InstanceIdentifier terminationPointIid = entry.getKey();
- Optional<TerminationPoint> terminationPointOptional =
- getOperationalState().getBridgeTerminationPoint(terminationPointIid);
- if (!terminationPointOptional.isPresent()) {
- // Configure interface
- String interfaceUuid = "Interface_" + SouthboundMapper.getRandomUUID();
- Interface ovsInterface =
- TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Interface.class);
- createInterface(terminationPoint, ovsInterface);
- transaction.add(op.insert(ovsInterface).withId(interfaceUuid));
-
- stampInstanceIdentifier(transaction, (InstanceIdentifier<TerminationPoint>) entry.getKey(),
- ovsInterface.getName());
-
- // Configure port with the above interface details
- String portUuid = "Port_" + SouthboundMapper.getRandomUUID();
- Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
- createPort(terminationPoint, port, interfaceUuid);
- transaction.add(op.insert(port).withId(portUuid));
-
- //Configure bridge with the above port details
- Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class);
- if (getBridge(entry.getKey()) != null) {
- bridge.setName(getBridge(entry.getKey()).getBridgeName().getValue());
- bridge.setPorts(Sets.newHashSet(new UUID(portUuid)));
-
- transaction.add(op.mutate(bridge)
- .addMutation(bridge.getPortsColumn().getSchema(),
- Mutator.INSERT,bridge.getPortsColumn().getData())
- .where(bridge.getNameColumn().getSchema()
- .opEqual(bridge.getNameColumn().getData())).build());
- }
+ public void execute(TransactionBuilder transaction, BridgeOperationalState state,
+ Collection<DataTreeModification<Node>> modifications) {
+ execute(transaction, state,
+ TransactUtils.extractCreated(modifications, OvsdbTerminationPointAugmentation.class),
+ TransactUtils.extractCreatedOrUpdated(modifications, Node.class));
+ }
+
+ private void execute(TransactionBuilder transaction, BridgeOperationalState state,
+ Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
+ OvsdbTerminationPointAugmentation>
+ createdTerminationPoints, Map<InstanceIdentifier<Node>, Node> nodes) {
+ for (Entry<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> entry :
+ createdTerminationPoints.entrySet()) {
+ OvsdbTerminationPointAugmentation terminationPoint = entry.getValue();
+ LOG.debug("Received request to create termination point {}",
+ terminationPoint.getName());
+ InstanceIdentifier terminationPointIid = entry.getKey();
+ Optional<TerminationPoint> terminationPointOptional =
+ state.getBridgeTerminationPoint(terminationPointIid);
+ if (!terminationPointOptional.isPresent()) {
+ // Configure interface
+ String interfaceUuid = "Interface_" + SouthboundMapper.getRandomUuid();
+ Interface ovsInterface =
+ TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Interface.class);
+ createInterface(terminationPoint, ovsInterface);
+ transaction.add(op.insert(ovsInterface).withId(interfaceUuid));
+
+ stampInstanceIdentifier(transaction, entry.getKey(), ovsInterface.getName());
+
+ // Configure port with the above interface details
+ String portUuid = "Port_" + SouthboundMapper.getRandomUuid();
+ Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
+ createPort(terminationPoint, port, interfaceUuid);
+ transaction.add(op.insert(port).withId(portUuid));
+
+ //Configure bridge with the above port details
+ Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class);
+ if (getBridge(entry.getKey(), nodes) != null) {
+ bridge.setName(getBridge(entry.getKey(), nodes).getBridgeName().getValue());
+ bridge.setPorts(Sets.newHashSet(new UUID(portUuid)));
+
+ transaction.add(op.mutate(bridge)
+ .addMutation(bridge.getPortsColumn().getSchema(),
+ Mutator.INSERT, bridge.getPortsColumn().getData())
+ .where(bridge.getNameColumn().getSchema()
+ .opEqual(bridge.getNameColumn().getData())).build());
}
}
}
createInterfaceOtherConfig(terminationPoint, ovsInterface);
createInterfaceExternalIds(terminationPoint, ovsInterface);
createInterfaceLldp(terminationPoint, ovsInterface);
+ createInterfaceBfd(terminationPoint, ovsInterface);
}
private void createInterfaceType(final OvsdbTerminationPointAugmentation terminationPoint,
//Configure optional input
if (terminationPoint.getOptions() != null) {
- Map<String, String> optionsMap = new HashMap<>();
- for (Options option : terminationPoint.getOptions()) {
- optionsMap.put(option.getOption(), option.getValue());
- }
try {
- ovsInterface.setOptions(ImmutableMap.copyOf(optionsMap));
+ ovsInterface.setOptions(YangUtils.convertYangKeyValueListToMap(terminationPoint.getOptions(),
+ Options::getOption, Options::getValue));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface options");
+ LOG.warn("Incomplete OVSDB interface options", e);
}
}
}
List<InterfaceExternalIds> interfaceExternalIds =
terminationPoint.getInterfaceExternalIds();
if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
- Map<String, String> externalIdsMap = new HashMap<>();
- for (InterfaceExternalIds externalId: interfaceExternalIds) {
- externalIdsMap.put(externalId.getExternalIdKey(), externalId.getExternalIdValue());
- }
try {
- ovsInterface.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
+ ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
+ InterfaceExternalIds::getExternalIdKey, InterfaceExternalIds::getExternalIdValue));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface external_ids");
+ LOG.warn("Incomplete OVSDB interface external_ids", e);
}
}
}
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
- List<InterfaceLldp> interfaceLldpList =
- terminationPoint.getInterfaceLldp();
- if (interfaceLldpList != null && !interfaceLldpList.isEmpty()) {
- Map<String, String> interfaceLldpMap = new HashMap<>();
- for (InterfaceLldp interfaceLldp : interfaceLldpList) {
- interfaceLldpMap.put(interfaceLldp.getLldpKey(), interfaceLldp.getLldpValue());
+ try {
+ List<InterfaceLldp> interfaceLldpList =
+ terminationPoint.getInterfaceLldp();
+ if (interfaceLldpList != null && !interfaceLldpList.isEmpty()) {
+ try {
+ ovsInterface.setLldp(YangUtils.convertYangKeyValueListToMap(interfaceLldpList,
+ InterfaceLldp::getLldpKey, InterfaceLldp::getLldpValue));
+ } catch (NullPointerException e) {
+ LOG.warn("Incomplete OVSDB interface lldp", e);
+ }
}
- try {
- ovsInterface.setLldp(ImmutableMap.copyOf(interfaceLldpMap));
- } catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface lldp");
+ } catch (SchemaVersionMismatchException e) {
+ schemaMismatchLog("lldp", "Interface", e);
+ }
+ }
+
+ private void createInterfaceBfd(final OvsdbTerminationPointAugmentation terminationPoint,
+ final Interface ovsInterface) {
+
+ try {
+ List<InterfaceBfd> interfaceBfdList = terminationPoint.getInterfaceBfd();
+ if (interfaceBfdList != null && !interfaceBfdList.isEmpty()) {
+ try {
+ ovsInterface.setBfd(YangUtils.convertYangKeyValueListToMap(interfaceBfdList,
+ InterfaceBfd::getBfdKey, InterfaceBfd::getBfdValue));
+ } catch (NullPointerException e) {
+ LOG.warn("Incomplete OVSDB interface bfd", e);
+ }
}
+ } catch (SchemaVersionMismatchException e) {
+ schemaMismatchLog("bfd", "Interface", e);
}
}
List<PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
if (portExternalIds != null && !portExternalIds.isEmpty()) {
- Map<String, String> externalIdsMap = new HashMap<>();
- for (PortExternalIds externalId: portExternalIds) {
- externalIdsMap.put(externalId.getExternalIdKey(), externalId.getExternalIdValue());
- }
try {
- port.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
+ port.setExternalIds(YangUtils.convertYangKeyValueListToMap(portExternalIds,
+ PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue));
} catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB port external_ids");
+ LOG.warn("Incomplete OVSDB port external_ids", e);
}
}
}
if (terminationPoint.getVlanMode() != null) {
Set<String> portVlanMode = new HashSet<>();
VlanMode modelVlanMode = terminationPoint.getVlanMode();
- portVlanMode.add(SouthboundConstants.VLANMODES.values()[modelVlanMode.getIntValue() - 1].getMode());
+ portVlanMode.add(SouthboundConstants.VlanModes.values()[modelVlanMode.getIntValue() - 1].getMode());
port.setVlanMode(portVlanMode);
}
}
List<PortOtherConfigs> portOtherConfigs =
terminationPoint.getPortOtherConfigs();
if (portOtherConfigs != null && !portOtherConfigs.isEmpty()) {
- Map<String, String> otherConfigsMap = new HashMap<>();
- for (PortOtherConfigs portOtherConfig : portOtherConfigs) {
- otherConfigsMap.put(portOtherConfig.getOtherConfigKey(),
- portOtherConfig.getOtherConfigValue());
- }
try {
- ovsPort.setOtherConfig(ImmutableMap.copyOf(otherConfigsMap));
+ ovsPort.setOtherConfig(YangUtils.convertYangKeyValueListToMap(portOtherConfigs,
+ PortOtherConfigs::getOtherConfigKey, PortOtherConfigs::getOtherConfigValue));
} catch (NullPointerException e) {
LOG.warn("Incomplete OVSDB port other_config", e);
}
}
}
- private OvsdbBridgeAugmentation getBridge(InstanceIdentifier<?> key) {
+ private OvsdbBridgeAugmentation getBridge(InstanceIdentifier<?> key, Map<InstanceIdentifier<Node>, Node> nodes) {
OvsdbBridgeAugmentation bridge = null;
InstanceIdentifier<Node> nodeIid = key.firstIdentifierOf(Node.class);
- Map<InstanceIdentifier<Node>, Node> nodes =
- TransactUtils.extractCreatedOrUpdated(getChanges(),Node.class);
if (nodes != null && nodes.get(nodeIid) != null) {
Node node = nodes.get(nodeIid);
bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
return bridge;
}
- public static void stampInstanceIdentifier(TransactionBuilder transaction,InstanceIdentifier<TerminationPoint> iid,
- String interfaceName) {
+ public static void stampInstanceIdentifier(TransactionBuilder transaction, InstanceIdentifier
+ <OvsdbTerminationPointAugmentation> iid, String interfaceName) {
Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
port.setName(interfaceName);
port.setExternalIds(Collections.<String,String>emptyMap());