/*
- * Copyright (c) 2015, 2016 Brocade Communications Systems, Inc. and others. All rights reserved.
+ * Copyright © 2015, 2017 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,
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.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
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.mdsal.binding.api.DataTreeModification;
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.lib.operations.TransactionBuilder;
-import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.Interface;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
+import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
-import org.opendaylight.ovsdb.southbound.SouthboundProvider;
+import org.opendaylight.ovsdb.southbound.SouthboundUtil;
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.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.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCreateCommand.class);
@Override
- public void execute(TransactionBuilder transaction, BridgeOperationalState state,
- AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> events) {
+ public void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+ final DataChangeEvent events, final InstanceIdentifierCodec instanceIdentifierCodec) {
execute(transaction, state, TransactUtils.extractCreated(events, OvsdbTerminationPointAugmentation.class),
- TransactUtils.extractCreatedOrUpdated(events, Node.class));
+ TransactUtils.extractCreatedOrUpdated(events, Node.class), instanceIdentifierCodec);
}
@Override
- public void execute(TransactionBuilder transaction, BridgeOperationalState state,
- Collection<DataTreeModification<Node>> modifications) {
+ public void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+ final Collection<DataTreeModification<Node>> modifications,
+ final InstanceIdentifierCodec instanceIdentifierCodec) {
execute(transaction, state,
TransactUtils.extractCreated(modifications, OvsdbTerminationPointAugmentation.class),
- TransactUtils.extractCreatedOrUpdated(modifications, Node.class));
+ TransactUtils.extractCreatedOrUpdated(modifications, Node.class), instanceIdentifierCodec);
}
- private void execute(TransactionBuilder transaction, BridgeOperationalState state,
- Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
- OvsdbTerminationPointAugmentation>
- createdTerminationPoints, Map<InstanceIdentifier<Node>, Node> nodes) {
+ private void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+ final Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
+ createdTerminationPoints,
+ final Map<InstanceIdentifier<Node>, Node> nodes, final InstanceIdentifierCodec instanceIdentifierCodec) {
for (Entry<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> entry :
createdTerminationPoints.entrySet()) {
OvsdbTerminationPointAugmentation terminationPoint = entry.getValue();
if (!terminationPointOptional.isPresent()) {
// Configure interface
String interfaceUuid = "Interface_" + SouthboundMapper.getRandomUuid();
- Interface ovsInterface =
- TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Interface.class);
+ Interface ovsInterface = transaction.getTypedRowWrapper(Interface.class);
createInterface(terminationPoint, ovsInterface);
transaction.add(op.insert(ovsInterface).withId(interfaceUuid));
- stampInstanceIdentifier(transaction, entry.getKey(), ovsInterface.getName());
+ stampInstanceIdentifier(transaction, entry.getKey(), ovsInterface.getName(), instanceIdentifierCodec);
// Configure port with the above interface details
String portUuid = "Port_" + SouthboundMapper.getRandomUuid();
- Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
- createPort(terminationPoint, port, interfaceUuid);
+ Port port = transaction.getTypedRowWrapper(Port.class);
+ final String opendaylightIid = instanceIdentifierCodec.serialize(terminationPointIid);
+ createPort(terminationPoint, port, interfaceUuid, opendaylightIid);
transaction.add(op.insert(port).withId(portUuid));
LOG.info("Created Termination Point : {} with Uuid : {}",
- terminationPoint.getName(),
- terminationPoint.getPortUuid());
+ terminationPoint.getName(),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)));
+ Bridge bridge = transaction.getTypedRowWrapper(Bridge.class);
+ String bridgeName = SouthboundUtil
+ .getBridgeNameFromOvsdbNodeId(entry.getKey().firstIdentifierOf(Node.class));
+ if (bridgeName != null) {
+ LOG.trace("Updating bridge {} for newly added port {}", bridgeName, terminationPoint.getName());
+ bridge.setName(bridgeName);
+ bridge.setPorts(Collections.singleton(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());
+ } else {
+ LOG.error("Missing BridgeName for Node {} during creation of port {}",
+ entry.getKey().firstIdentifierOf(Node.class), terminationPoint.getName());
}
}
}
createInterfaceBfd(terminationPoint, ovsInterface);
}
- private void createInterfaceType(final OvsdbTerminationPointAugmentation terminationPoint,
- final Interface ovsInterface) {
-
+ private static 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) {
+ final Port port, final String interfaceUuid, final String opendaylightIid) {
port.setName(terminationPoint.getName());
- port.setInterfaces(Sets.newHashSet(new UUID(interfaceUuid)));
+ port.setInterfaces(Collections.singleton(new UUID(interfaceUuid)));
createPortOtherConfig(terminationPoint, port);
createPortVlanTag(terminationPoint, port);
createPortVlanTrunk(terminationPoint, port);
createPortVlanMode(terminationPoint, port);
- createPortExternalIds(terminationPoint, port);
+ createPortExternalIds(terminationPoint, port, opendaylightIid);
}
private void createOfPort(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
- Long ofPort = terminationPoint.getOfport();
+ Uint32 ofPort = terminationPoint.getOfport();
if (ofPort != null) {
- ovsInterface.setOpenFlowPort(Sets.newHashSet(ofPort));
+ ovsInterface.setOpenFlowPort(Collections.singleton(ofPort.toJava()));
}
}
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
- Integer ofPortRequest = terminationPoint.getOfportRequest();
+ Uint16 ofPortRequest = terminationPoint.getOfportRequest();
if (ofPortRequest != null) {
- ovsInterface.setOpenFlowPortRequest(Sets.newHashSet(ofPortRequest.longValue()));
+ ovsInterface.setOpenFlowPortRequest(Collections.singleton(ofPortRequest.longValue()));
}
}
List<InterfaceExternalIds> interfaceExternalIds =
terminationPoint.getInterfaceExternalIds();
if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
- try {
- ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
- InterfaceExternalIds::getExternalIdKey, InterfaceExternalIds::getExternalIdValue));
- } catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB interface external_ids", e);
- }
+ interfaceExternalIds.add(SouthboundUtil.createExternalIdsForInterface(
+ SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+ } else {
+ interfaceExternalIds = Arrays.asList(SouthboundUtil.createExternalIdsForInterface(
+ SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+ }
+ try {
+ ovsInterface.setExternalIds(YangUtils.convertYangKeyValueListToMap(interfaceExternalIds,
+ InterfaceExternalIds::getExternalIdKey, InterfaceExternalIds::getExternalIdValue));
+ } catch (NullPointerException e) {
+ LOG.warn("Incomplete OVSDB interface external_ids", e);
}
}
private void createPortExternalIds(
final OvsdbTerminationPointAugmentation terminationPoint,
- final Port port) {
+ final Port port, final String opendaylightIid) {
+ // Set the iid external_id
List<PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
if (portExternalIds != null && !portExternalIds.isEmpty()) {
- try {
- port.setExternalIds(YangUtils.convertYangKeyValueListToMap(portExternalIds,
- PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue));
- } catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB port external_ids", e);
- }
+ portExternalIds.add(SouthboundUtil.createExternalIdsForPort(
+ SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+ portExternalIds.add(SouthboundUtil.createExternalIdsForPort(
+ SouthboundConstants.IID_EXTERNAL_ID_KEY, opendaylightIid));
+ } else {
+ portExternalIds = new ArrayList<>();
+ portExternalIds.add(SouthboundUtil.createExternalIdsForPort(
+ SouthboundConstants.CREATED_BY, SouthboundConstants.ODL));
+ portExternalIds.add(SouthboundUtil.createExternalIdsForPort(
+ SouthboundConstants.IID_EXTERNAL_ID_KEY, opendaylightIid));
+ }
+ try {
+ port.setExternalIds(YangUtils.convertYangKeyValueListToMap(portExternalIds,
+ PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue));
+ //YangUtils.copyYangKeyValueListToMap(externalIdMap, terminationPoint.getPortExternalIds(),
+ // PortExternalIds::getExternalIdKey, PortExternalIds::getExternalIdValue);
+ } catch (NullPointerException e) {
+ LOG.warn("Incomplete OVSDB port external_ids", e);
}
}
}
}
- private OvsdbBridgeAugmentation getBridge(InstanceIdentifier<?> key, Map<InstanceIdentifier<Node>, Node> nodes) {
- OvsdbBridgeAugmentation bridge = null;
- InstanceIdentifier<Node> nodeIid = key.firstIdentifierOf(Node.class);
- if (nodes != null && nodes.get(nodeIid) != null) {
- Node node = nodes.get(nodeIid);
- 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 bridge;
- }
-
- public static void stampInstanceIdentifier(TransactionBuilder transaction, InstanceIdentifier
- <OvsdbTerminationPointAugmentation> iid, String interfaceName) {
- Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
+ public static void stampInstanceIdentifier(final TransactionBuilder transaction,
+ final InstanceIdentifier<OvsdbTerminationPointAugmentation> iid, final String interfaceName,
+ final InstanceIdentifierCodec instanceIdentifierCodec) {
+ Port port = transaction.getTypedRowWrapper(Port.class);
port.setName(interfaceName);
- port.setExternalIds(Collections.<String,String>emptyMap());
- Mutate mutate = TransactUtils.stampInstanceIdentifierMutation(transaction,
- iid,
- port.getSchema(),
- port.getExternalIdsColumn().getSchema());
+ port.setExternalIds(Collections.emptyMap());
+ Mutate mutate = TransactUtils.stampInstanceIdentifierMutation(transaction, iid, port.getSchema(),
+ port.getExternalIdsColumn().getSchema(), instanceIdentifierCodec);
transaction.add(mutate
.where(port.getNameColumn().getSchema().opEqual(interfaceName))
.build());
}
-
}
Code Review / ovsdb.git / blobdiff