import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+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 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.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
+import org.opendaylight.ovsdb.lib.operations.Mutate;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
+import org.opendaylight.ovsdb.southbound.SouthboundProvider;
+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.PortOtherConfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Trunks;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
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 {
OvsdbTerminationPointAugmentation terminationPoint = (OvsdbTerminationPointAugmentation) dataObject;
LOG.debug("Received request to create termination point {}",
terminationPoint.getName());
-
- // 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));
-
- // 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);
- 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());
+ 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());
+ }
+ }
}
}
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
ovsInterface.setName(terminationPoint.getName());
- ovsInterface.setType(SouthboundMapper.createOvsdbInterfaceType(terminationPoint.getInterfaceType()));
+ createInterfaceType(terminationPoint, ovsInterface);
createOfPort(terminationPoint, ovsInterface);
createOfPortRequest(terminationPoint, ovsInterface);
createInterfaceOptions(terminationPoint, ovsInterface);
createInterfaceExternalIds(terminationPoint, ovsInterface);
}
+ private void createInterfaceType(final OvsdbTerminationPointAugmentation terminationPoint,
+ final Interface ovsInterface) {
+
+ Class<? extends InterfaceTypeBase> mdsaltype = terminationPoint.getInterfaceType();
+ if (mdsaltype != null) {
+ ovsInterface.setType(SouthboundMapper.createOvsdbInterfaceType(mdsaltype));
+ }
+ }
+
private void createPort(
final OvsdbTerminationPointAugmentation terminationPoint,
final Port port, final String interfaceUuid) {
//Configure optional input
if (terminationPoint.getOptions() != null) {
- HashMap<String, String> optionsMap = new HashMap<String, String>();
+ Map<String, String> optionsMap = new HashMap<String, String>();
for (Options option : terminationPoint.getOptions()) {
optionsMap.put(option.getOption(), option.getValue());
}
List<InterfaceExternalIds> interfaceExternalIds =
terminationPoint.getInterfaceExternalIds();
if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
- HashMap<String, String> externalIdsMap = new HashMap<String, String>();
+ Map<String, String> externalIdsMap = new HashMap<String, String>();
for (InterfaceExternalIds externalId: interfaceExternalIds) {
externalIdsMap.put(externalId.getExternalIdKey(), externalId.getExternalIdValue());
}
List<InterfaceOtherConfigs> interfaceOtherConfigs =
terminationPoint.getInterfaceOtherConfigs();
if (interfaceOtherConfigs != null && !interfaceOtherConfigs.isEmpty()) {
- HashMap<String, String> otherConfigsMap = new HashMap<String, String>();
+ Map<String, String> otherConfigsMap = new HashMap<String, String>();
for (InterfaceOtherConfigs interfaceOtherConfig : interfaceOtherConfigs) {
otherConfigsMap.put(interfaceOtherConfig.getOtherConfigKey(),
interfaceOtherConfig.getOtherConfigValue());
List<PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
if (portExternalIds != null && !portExternalIds.isEmpty()) {
- HashMap<String, String> externalIdsMap = new HashMap<String, String>();
+ Map<String, String> externalIdsMap = new HashMap<String, String>();
for (PortExternalIds externalId: portExternalIds) {
externalIdsMap.put(externalId.getExternalIdKey(), externalId.getExternalIdValue());
}
List<PortOtherConfigs> portOtherConfigs =
terminationPoint.getPortOtherConfigs();
if (portOtherConfigs != null && !portOtherConfigs.isEmpty()) {
- HashMap<String, String> otherConfigsMap = new HashMap<String, String>();
+ Map<String, String> otherConfigsMap = new HashMap<String, String>();
for (PortOtherConfigs portOtherConfig : portOtherConfigs) {
otherConfigsMap.put(portOtherConfig.getOtherConfigKey(),
portOtherConfig.getOtherConfigValue());
}
private OvsdbBridgeAugmentation getBridge(InstanceIdentifier<?> key) {
+ 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);
- OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
- if (bridge != null) {
- return bridge;
+ bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
+ if (bridge == null) {
+ ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction();
+ CheckedFuture<Optional<Node>, ReadFailedException> future =
+ transaction.read(LogicalDatastoreType.OPERATIONAL, nodeIid);
+ try {
+ Optional<Node> nodeOptional = future.get();
+ if (nodeOptional.isPresent()) {
+ bridge = nodeOptional.get().getAugmentation(OvsdbBridgeAugmentation.class);
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Error reading from datastore",e);
+ }
+ transaction.close();
}
}
- return null;
+ return bridge;
+ }
+
+ public static void stampInstanceIdentifier(TransactionBuilder transaction,InstanceIdentifier<TerminationPoint> iid,
+ String interfaceName) {
+ Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
+ port.setName(interfaceName);;
+ port.setExternalIds(Collections.<String,String>emptyMap());
+ Mutate mutate = TransactUtils.stampInstanceIdentifierMutation(transaction,
+ iid,
+ port.getSchema(),
+ port.getExternalIdsColumn().getSchema());
+ transaction.add(mutate
+ .where(port.getNameColumn().getSchema().opEqual(interfaceName))
+ .build());
}
}
Code Review / ovsdb.git / blobdiff