RWUtils.getCurrentIdItem(id, key);
final InstanceIdentifier<C> keyedId = RWUtils.replaceLastInId(id, currentBdItem);
final Optional<C> read = readCurrent(keyedId, ctx);
- final DataObject singleItem = read.get();
- checkArgument(getManagedDataObjectType().getTargetType().isAssignableFrom(singleItem.getClass()));
- allEntries.add(getManagedDataObjectType().getTargetType().cast(singleItem));
+ if(read.isPresent()) {
+ final DataObject singleItem = read.get();
+ checkArgument(getManagedDataObjectType().getTargetType().isAssignableFrom(singleItem.getClass()));
+ allEntries.add(getManagedDataObjectType().getTargetType().cast(singleItem));
+ }
}
return allEntries;
}
final WriteContext ctx) throws WriteFailedException {
LOG.debug("{}: Updating current: {} dataBefore: {}, datAfter: {}", this, id, dataBefore, dataAfter);
+/* FIXME: Equals does not work: LINK */
if (dataBefore.equals(dataAfter)) {
LOG.debug("{}: Skipping current(no update): {}", this, id);
// No change, ignore
@Override
public void deleteChild(@Nonnull final InstanceIdentifier<? extends DataObject> parentId,
- @Nonnull final DataObject parentData,
+ @Nonnull final DataObject parentDataBefore,
@Nonnull final WriteContext ctx) throws WriteFailedException {
final InstanceIdentifier<D> currentId = RWUtils.appendTypeToId(parentId, getManagedDataObjectType());
- final Optional<D> currentData = customizer.extract(currentId, parentData);
- if(currentData.isPresent()) {
- deleteCurrent(currentId, currentData.get(), ctx);
+ final Optional<D> dataBefore = customizer.extract(currentId, parentDataBefore);
+ if(dataBefore.isPresent()) {
+ deleteCurrent(currentId, dataBefore.get(), ctx);
}
}
final InstanceIdentifier<D> currentId = RWUtils.appendTypeToId(parentId, getManagedDataObjectType());
final Optional<D> before = customizer.extract(currentId, parentDataBefore);
final Optional<D> after = customizer.extract(currentId, parentDataAfter);
- if(before.isPresent() && after.isPresent()) {
- updateCurrent(currentId, before.get(), after.get(), ctx);
+
+ if(before.isPresent()) {
+ if(after.isPresent()) {
+ updateCurrent(currentId, before.get(), after.get(), ctx);
+ } else {
+ deleteCurrent(currentId, before.get(), ctx);
+ }
+ } else if (after.isPresent()){
+ writeCurrent(currentId, after.get(), ctx);
}
}
}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.v3po.translate.util.write;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.v3po.translate.spi.write.ChildWriterCustomizer;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.binding.Augmentable;
+import org.opendaylight.yangtools.yang.binding.Augmentation;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Might be slow !
+ */
+public class ReflexiveAugmentWriterCustomizer<C extends DataObject> extends NoopWriterCustomizer<C> implements
+ ChildWriterCustomizer<C> {
+
+ @Nonnull
+ @Override
+ @SuppressWarnings("unchecked")
+ public Optional<C> extract(@Nonnull final InstanceIdentifier<C> currentId, @Nonnull final DataObject parentData) {
+ checkArgument(parentData instanceof Augmentable<?>, "Not augmnatable parent object: %s", parentData);
+ final Class<C> currentType = currentId.getTargetType();
+ final Augmentation<?> augmentation = ((Augmentable) parentData).getAugmentation(currentType);
+ if(augmentation == null) {
+ return Optional.absent();
+ } else {
+ checkState(currentType.isAssignableFrom(augmentation.getClass()));
+ return Optional.of(currentType.cast(augmentation));
+ }
+ }
+}
import io.fd.honeycomb.v3po.translate.Context;
import io.fd.honeycomb.v3po.translate.spi.write.ListWriterCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.VppApiCustomizer;
+import io.fd.honeycomb.v3po.translate.v3po.util.VppApiInvocationException;
+import io.fd.honeycomb.v3po.translate.v3po.utils.V3poUtils;
+import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import java.util.List;
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.openvpp.vppjapi.vppApi;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Ietf interface write customizer that only caches interface objects for child writers
*/
public class InterfaceCustomizer extends VppApiCustomizer implements ListWriterCustomizer<Interface, InterfaceKey> {
- public static final String IFC_AFTER_CTX = InterfaceCustomizer.class.toString() + "ifcAfter";
- public static final String IFC_BEFORE_CTX = InterfaceCustomizer.class.toString() + "ifcBefore";
+ private static final Logger LOG = LoggerFactory.getLogger(InterfaceCustomizer.class);
public InterfaceCustomizer(final vppApi vppApi) {
super(vppApi);
@Override
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataAfter,
- @Nonnull final Context writeContext) {
- writeContext.put(IFC_AFTER_CTX, dataAfter);
+ @Nonnull final Context writeContext)
+ throws WriteFailedException {
+
+ try {
+ setInterface(id, dataAfter);
+ } catch (VppApiInvocationException e) {
+ LOG.warn("Update of VppInterfaceAugment failed", e);
+ throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
+ }
}
@Override
public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataBefore,
@Nonnull final Interface dataAfter,
- @Nonnull final Context writeContext) {
- writeContext.put(IFC_BEFORE_CTX, dataBefore);
- writeContext.put(IFC_AFTER_CTX, dataAfter);
+ @Nonnull final Context writeContext)
+ throws WriteFailedException.UpdateFailedException {
+
+ try {
+ updateInterface(id, dataBefore, dataAfter);
+ } catch (VppApiInvocationException e) {
+ LOG.warn("Update of VppInterfaceAugment failed", e);
+ throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
+ }
}
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataBefore,
@Nonnull final Context writeContext) {
- writeContext.put(IFC_BEFORE_CTX, dataBefore);
+
+ // TODO Handle deletes
}
@Nonnull
@Nonnull final DataObject parentData) {
return ((Interfaces) parentData).getInterface();
}
+
+
+ private void setInterface(final InstanceIdentifier<Interface> id, final Interface swIf)
+ throws VppApiInvocationException, WriteFailedException {
+ LOG.info("Setting interface {}, type: {}", swIf.getName(), swIf.getType().getSimpleName());
+ LOG.debug("Setting interface {}", swIf);
+
+ String swIfName = swIf.getName();
+ int swIfIndex = getVppApi().swIfIndexFromName(swIfName);
+
+ setInterfaceAttributes(swIf, swIfName);
+ }
+
+ private void setInterfaceAttributes(final Interface swIf, final String swIfName)
+ throws VppApiInvocationException {
+ LOG.debug("Creating {} interface {}", swIf.getType().getSimpleName(), swIf.getName());
+
+ setInterfaceFlags(swIfName, getVppApi().swIfIndexFromName(swIfName),
+ swIf.isEnabled() ? (byte) 1 : (byte) 0);
+
+ setDescription(swIf);
+ }
+
+ private void updateInterface(final InstanceIdentifier<Interface> id,
+ final Interface dataBefore,
+ final Interface dataAfter) throws VppApiInvocationException {
+ LOG.info("Updating interface {}, type: {}", dataAfter.getName(), dataAfter.getType().getSimpleName());
+ LOG.debug("Updating interface {}", dataAfter);
+
+ String swIfName = dataAfter.getName();
+ int swIfIndex = getVppApi().swIfIndexFromName(swIfName);
+
+ setInterfaceAttributes(dataAfter, swIfName);
+ }
+
+ private void setInterfaceFlags(final String swIfName, final int swIfIndex, final byte enabled)
+ throws VppApiInvocationException {
+ int ctxId = getVppApi().swInterfaceSetFlags(swIfIndex, enabled, enabled, (byte) 0 /* deleted */);
+
+ LOG.debug("Updating interface flags for: {}, index: {}, enabled: {}, ctxId: {}", swIfName, swIfIndex,
+ enabled, ctxId);
+
+ final int rv = V3poUtils.waitForResponse(ctxId, getVppApi());
+ if (rv < 0) {
+ LOG.warn("Failed to update interface flags for: {}, index: {}, enabled: {}, ctxId: {}", swIfName, swIfIndex,
+ enabled, ctxId);
+ throw new VppApiInvocationException("swInterfaceSetFlags", ctxId, rv);
+ } else {
+ LOG.debug("Interface flags updated successfully for: {}, index: {}, enabled: {}, ctxId: {}",
+ swIfName, swIfIndex, enabled, ctxId);
+ }
+ }
+
+ private void setDescription(final Interface swIf) {
+ if (swIf.getDescription() != null) {
+ getVppApi().setInterfaceDescription(swIf.getName(), swIf.getDescription());
+ } else {
+ getVppApi().setInterfaceDescription(swIf.getName(), "");
+ }
+ }
}
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter,
@Nonnull final Context writeContext)
throws WriteFailedException {
- final Interface ifc = (Interface) writeContext.get(InterfaceCustomizer.IFC_AFTER_CTX);
- final int swIfc = getSwIfc(ifc);
+ final String ifcName = id.firstKeyOf(Interface.class).getName();
+ final int swIfc = getSwIfc(ifcName);
try {
- setL2(id, swIfc, ifc, dataAfter);
+ setL2(id, swIfc, ifcName, dataAfter);
} catch (VppApiInvocationException e) {
LOG.warn("Write of L2 failed", e);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore,
@Nonnull final L2 dataAfter, @Nonnull final Context writeContext)
throws WriteFailedException {
- final Interface ifcBefore = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
- final Interface ifcAfter = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
- final int swIfc = getSwIfc(ifcBefore);
+ final String ifcName = id.firstKeyOf(Interface.class).getName();
+ final int swIfc = getSwIfc(ifcName);
// TODO handle update properly (if possible)
try {
- setL2(id, swIfc, ifcAfter, dataAfter);
+ setL2(id, swIfc, ifcName, dataAfter);
} catch (VppApiInvocationException e) {
LOG.warn("Update of L2 failed", e);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
}
}
- private int getSwIfc(final Interface ifcBefore) {
- int swIfcIndex = getVppApi().swIfIndexFromName(ifcBefore.getName());
- checkArgument(swIfcIndex != -1, "Interface %s does not exist", ifcBefore.getName());
+ private int getSwIfc(final String ifcName) {
+ int swIfcIndex = getVppApi().swIfIndexFromName(ifcName);
+ checkArgument(swIfcIndex != -1, "Interface %s does not exist", ifcName);
return swIfcIndex;
}
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore,
@Nonnull final Context writeContext) {
- final Interface ifcBefore = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
-
- final int swIfc = getSwIfc(ifcBefore);
// TODO implement delete (if possible)
}
- private void setL2(final InstanceIdentifier<L2> id, final int swIfIndex, final Interface ifc, final L2 vppL2)
+ private void setL2(final InstanceIdentifier<L2> id, final int swIfIndex, final String ifcName, final L2 vppL2)
throws VppApiInvocationException, WriteFailedException {
- LOG.debug("Setting L2 for interface: %s", ifc.getName());
+ LOG.debug("Setting L2 for interface: %s", ifcName);
// Nothing besides interconnection here
- setInterconnection(id, swIfIndex, ifc, vppL2);
+ setInterconnection(id, swIfIndex, ifcName, vppL2);
}
- private void setInterconnection(final InstanceIdentifier<L2> id, final int swIfIndex, final Interface ifc,
+ private void setInterconnection(final InstanceIdentifier<L2> id, final int swIfIndex, final String ifcName,
final L2 vppL2)
throws VppApiInvocationException, WriteFailedException {
Interconnection ic = vppL2.getInterconnection();
if (ic instanceof XconnectBased) {
- setXconnectBasedL2(swIfIndex, ifc, (XconnectBased) ic);
+ setXconnectBasedL2(swIfIndex, ifcName, (XconnectBased) ic);
} else if (ic instanceof BridgeBased) {
- setBridgeBasedL2(swIfIndex, ifc, (BridgeBased) ic);
+ setBridgeBasedL2(swIfIndex, ifcName, (BridgeBased) ic);
} else {
// FIXME how does choice extensibility work
// FIXME it is not even possible to create a dedicated customizer for Interconnection, since it's not a DataObject
}
}
- private void setBridgeBasedL2(final int swIfIndex, final Interface ifc, final BridgeBased bb)
+ private void setBridgeBasedL2(final int swIfIndex, final String ifcName, final BridgeBased bb)
throws VppApiInvocationException {
LOG.debug("Setting bridge based interconnection(bridge-domain=%s) for interface: %s",
- bb.getBridgeDomain(), ifc.getName());
+ bb.getBridgeDomain(), ifcName);
String bdName = bb.getBridgeDomain();
int bdId = getVppApi().bridgeDomainIdFromName(bdName);
checkArgument(bdId > 0, "Unable to set Interconnection for Interface: %s, bridge domain: %s does not exist",
- ifc.getName(), bdName);
+ ifcName, bdName);
byte bvi = bb.isBridgedVirtualInterface()
? (byte) 1
final int rv = V3poUtils.waitForResponse(ctxId, getVppApi());
if (rv < 0) {
- LOG.warn("Failed to update bridge based interconnection flags for: {}, interconnection: {}", ifc.getName(),
+ LOG.warn("Failed to update bridge based interconnection flags for: {}, interconnection: {}", ifcName,
bb);
throw new VppApiInvocationException("swInterfaceSetL2Bridge", ctxId, rv);
} else {
- LOG.debug("Bridge based interconnection updated successfully for: {}, interconnection: {}", ifc.getName(),
+ LOG.debug("Bridge based interconnection updated successfully for: {}, interconnection: {}", ifcName,
bb);
}
}
- private void setXconnectBasedL2(final int swIfIndex, final Interface ifc, final XconnectBased ic)
+ private void setXconnectBasedL2(final int swIfIndex, final String ifcName, final XconnectBased ic)
throws VppApiInvocationException {
String outSwIfName = ic.getXconnectOutgoingInterface();
LOG.debug("Setting xconnect based interconnection(outgoing ifc=%s) for interface: %s", outSwIfName,
- ifc.getName());
+ ifcName);
int outSwIfIndex = getVppApi().swIfIndexFromName(outSwIfName);
checkArgument(outSwIfIndex > 0,
"Unable to set Interconnection for Interface: %s, outgoing interface: %s does not exist",
- ifc.getName(), outSwIfIndex);
+ ifcName, outSwIfIndex);
int ctxId = getVppApi().swInterfaceSetL2Xconnect(swIfIndex, outSwIfIndex, (byte) 1 /* enable */);
final int rv = V3poUtils.waitForResponse(ctxId, getVppApi());
if (rv < 0) {
LOG.warn("Failed to update xconnect based interconnection flags for: {}, interconnection: {}",
- ifc.getName(), ic);
+ ifcName, ic);
throw new VppApiInvocationException("swInterfaceSetL2Xconnect", ctxId, rv);
} else {
- LOG.debug("Xconnect based interconnection updated successfully for: {}, interconnection: {}", ifc.getName(),
+ LOG.debug("Xconnect based interconnection updated successfully for: {}, interconnection: {}", ifcName,
ic);
}
}
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataAfter, @Nonnull final Context writeContext)
throws WriteFailedException.CreateFailedException {
- final Interface ifc = (Interface) writeContext.get(InterfaceCustomizer.IFC_AFTER_CTX);
try {
- setRouting(ifc.getName(), dataAfter);
+ setRouting(id.firstKeyOf(Interface.class).getName(), dataAfter);
} catch (VppApiInvocationException e) {
LOG.warn("Update of Routing failed", e);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
@Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter,
@Nonnull final Context writeContext)
throws WriteFailedException.UpdateFailedException {
- final Interface ifcBefore = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
- final Interface ifcAfter = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
try {
// TODO handle updates properly
- setRouting(ifcAfter.getName(), dataAfter);
+ setRouting(id.firstKeyOf(Interface.class).getName(), dataAfter);
} catch (VppApiInvocationException e) {
LOG.warn("Update of Routing failed", e);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.fd.honeycomb.v3po.translate.v3po.interfaces;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.base.Optional;
-import io.fd.honeycomb.v3po.translate.Context;
-import io.fd.honeycomb.v3po.translate.spi.write.ChildWriterCustomizer;
-import io.fd.honeycomb.v3po.translate.v3po.util.VppApiCustomizer;
-import io.fd.honeycomb.v3po.translate.v3po.util.VppApiInvocationException;
-import io.fd.honeycomb.v3po.translate.v3po.utils.V3poUtils;
-import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.EthernetCsmacd;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VxlanTunnel;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class VppInterfaceCustomizer extends VppApiCustomizer
- implements ChildWriterCustomizer<VppInterfaceAugmentation> {
-
- private static final Logger LOG = LoggerFactory.getLogger(VppInterfaceCustomizer.class);
-
- public VppInterfaceCustomizer(final org.openvpp.vppjapi.vppApi vppApi) {
- super(vppApi);
- }
-
- @Nonnull
- @Override
- public Optional<VppInterfaceAugmentation> extract(
- @Nonnull final InstanceIdentifier<VppInterfaceAugmentation> currentId,
- @Nonnull final DataObject parentData) {
- return Optional.fromNullable(((Interface) parentData).getAugmentation(VppInterfaceAugmentation.class));
- }
-
- @Override
- public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<VppInterfaceAugmentation> id,
- @Nonnull final VppInterfaceAugmentation dataAfter,
- @Nonnull final Context writeContext)
- throws WriteFailedException {
- final Interface ifc = (Interface) writeContext.get(InterfaceCustomizer.IFC_AFTER_CTX);
- try {
- setInterface(id, ifc, dataAfter);
- } catch (VppApiInvocationException e) {
- LOG.warn("Update of VppInterfaceAugment failed", e);
- throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
- }
- }
-
- @Override
- public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VppInterfaceAugmentation> id,
- @Nonnull final VppInterfaceAugmentation dataBefore,
- @Nonnull final VppInterfaceAugmentation dataAfter,
- @Nonnull final Context writeContext)
- throws WriteFailedException.UpdateFailedException {
- final Interface ifcBefore = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
- final Interface ifc = (Interface) writeContext.get(InterfaceCustomizer.IFC_AFTER_CTX);
- try {
- updateInterface(id, ifc, dataBefore, dataAfter);
- } catch (VppApiInvocationException e) {
- LOG.warn("Update of VppInterfaceAugment failed", e);
- throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
- }
- }
-
- @Override
- public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VppInterfaceAugmentation> id,
- @Nonnull final VppInterfaceAugmentation dataBefore,
- @Nonnull final Context writeContext) {
- final Interface ifcBefore = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
-
- LOG.info("Deleting interface: {}, type: {}", ifcBefore.getName(), ifcBefore.getType().getSimpleName());
-
- if (ifcBefore.getType().isAssignableFrom(EthernetCsmacd.class)) {
- LOG.error("Interface {}, type: {} cannot be deleted",
- ifcBefore.getName(), ifcBefore.getType().getSimpleName());
-
- /* FIXME: Add additional interface types here.
- *
- * } else if (swIf.getType().isAssignableFrom(*.class)) {
- */
-
- }
- }
-
-
- private void updateInterface(final InstanceIdentifier<VppInterfaceAugmentation> id, final Interface swIf,
- final VppInterfaceAugmentation dataBefore,
- final VppInterfaceAugmentation dataAfter) throws VppApiInvocationException {
- LOG.info("Updating interface {}, type: {}", swIf.getName(), swIf.getType().getSimpleName());
- LOG.debug("Updating interface {}", swIf);
-
- Class<? extends InterfaceType> ifType = checkNotNull(swIf.getType(), "Interface type missing for %s", swIf);
- String swIfName = swIf.getName();
- int swIfIndex = getVppApi().swIfIndexFromName(swIfName);
- checkArgument(swIfIndex != -1, "Updating non-existing vpp interface: %s", swIfName);
-
- // TODO handle updates properly
-
- if (VxlanTunnel.class.isAssignableFrom(ifType)) {
- updateVxlanTunnelInterface(swIf);
- } else if (EthernetCsmacd.class.isAssignableFrom(ifType)) {
- updateEthernetCsmacdInterface(swIf, swIfName, swIfIndex);
- }
- }
-
-
- private void setInterface(final InstanceIdentifier<VppInterfaceAugmentation> id, final Interface swIf,
- final VppInterfaceAugmentation dataAfter)
- throws VppApiInvocationException, WriteFailedException {
- LOG.info("Setting interface {}, type: {}", swIf.getName(), swIf.getType().getSimpleName());
- LOG.debug("Setting interface {}", swIf);
-
- Class<? extends InterfaceType> ifType = checkNotNull(swIf.getType(), "Interface type missing for %s", swIf);
- String swIfName = swIf.getName();
- int swIfIndex = getVppApi().swIfIndexFromName(swIfName);
- checkArgument(swIfIndex == -1, "Creating already-existing vpp interface: %s", swIfName);
-
- if (VxlanTunnel.class.isAssignableFrom(ifType)) {
- createVxlanTunnelInterface(swIf, swIfName);
- } else if (EthernetCsmacd.class.isAssignableFrom(ifType)) {
- createEthernetCsmacdInterface(id, swIfName, dataAfter);
- }
- }
-
- private void createVxlanTunnelInterface(final Interface swIf, final String swIfName)
- throws VppApiInvocationException {
- LOG.debug("Creating {} interface {}", swIf.getType().getSimpleName(), swIf.getName());
-
- // FIXME, Vxlan child writer needs to be handled before this is
- int newSwIfIndex = getVppApi().swIfIndexFromName(swIfName);
-
- setInterfaceFlags(swIfName, newSwIfIndex, swIf.isEnabled()
- ? (byte) 1
- : (byte) 0);
- setDescription(swIf);
- }
-
- private void updateVxlanTunnelInterface(final Interface swIf) {
- LOG.debug("Updating {} interface {}", swIf.getType().getSimpleName(), swIf.getName());
-
- // TODO handle
- }
-
- private void createEthernetCsmacdInterface(final InstanceIdentifier<VppInterfaceAugmentation> id,
- final String swIfName, final VppInterfaceAugmentation dataAfter) throws WriteFailedException {
- LOG.warn("Unable to create interface: {}, type: {}", swIfName, EthernetCsmacd.class);
- throw new WriteFailedException.CreateFailedException(id, dataAfter);
- }
-
- private void updateEthernetCsmacdInterface(final Interface swIf,
- final String swIfName, final int swIfIndex)
- throws VppApiInvocationException {
- LOG.debug("Updating {} interface {}", swIf.getType().getSimpleName(), swIf.getName());
- byte enabled = swIf.isEnabled()
- ? (byte) 1
- : (byte) 0;
- setInterfaceFlags(swIfName, swIfIndex, enabled);
- setDescription(swIf);
- }
-
- private void setInterfaceFlags(final String swIfName, final int swIfIndex, final byte enabled)
- throws VppApiInvocationException {
- int ctxId = getVppApi().swInterfaceSetFlags(swIfIndex, enabled, enabled, (byte) 0 /* deleted */);
-
- LOG.debug("Updating interface flags for: {}, index: {}, enabled: {}, ctxId: {}", swIfName, swIfIndex,
- enabled, ctxId);
-
- final int rv = V3poUtils.waitForResponse(ctxId, getVppApi());
- if (rv < 0) {
- LOG.warn("Failed to update interface flags for: {}, index: {}, enabled: {}, ctxId: {}", swIfName, swIfIndex,
- enabled, ctxId);
- throw new VppApiInvocationException("swInterfaceSetFlags", ctxId, rv);
- } else {
- LOG.debug("Interface flags updated successfully for: {}, index: {}, enabled: {}, ctxId: {}",
- swIfName, swIfIndex, enabled, ctxId);
- }
- }
-
- private void setDescription(final Interface swIf) {
- if (swIf.getDescription() != null) {
- getVppApi().setInterfaceDescription(swIf.getName(), swIf.getDescription());
- } else {
- getVppApi().setInterfaceDescription(swIf.getName(), "");
- }
- }
-
-}
-
import com.google.common.base.Optional;
import io.fd.honeycomb.v3po.translate.Context;
-import io.fd.honeycomb.v3po.translate.v3po.util.VppApiInvocationException;
import io.fd.honeycomb.v3po.translate.spi.write.ChildWriterCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.VppApiCustomizer;
+import io.fd.honeycomb.v3po.translate.v3po.util.VppApiInvocationException;
import io.fd.honeycomb.v3po.translate.v3po.utils.V3poUtils;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import javax.annotation.Nonnull;
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataAfter,
@Nonnull final Context writeContext)
throws WriteFailedException.CreateFailedException {
- final Interface ifc = (Interface) writeContext.get(InterfaceCustomizer.IFC_AFTER_CTX);
try {
- createVxlanTunnel(ifc.getName(), dataAfter);
+ createVxlanTunnel(id.firstKeyOf(Interface.class).getName(), dataAfter);
} catch (VppApiInvocationException e) {
LOG.warn("Write of Vxlan failed", e);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore,
@Nonnull final Vxlan dataAfter, @Nonnull final Context writeContext)
throws WriteFailedException.UpdateFailedException {
- final Interface ifcBefore = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
- final Interface ifcAfter = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
// TODO handle update in a better way
try {
- createVxlanTunnel(ifcAfter.getName(), dataAfter);
+ createVxlanTunnel(id.firstKeyOf(Interface.class).getName(), dataAfter);
} catch (VppApiInvocationException e) {
LOG.warn("Update of L2 failed", e);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore,
@Nonnull final Context writeContext) {
- final Interface ifcBefore = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
// TODO handle delete
}
import com.google.common.base.Optional;
import io.fd.honeycomb.v3po.translate.Context;
import io.fd.honeycomb.v3po.translate.spi.write.ChildWriterCustomizer;
-import io.fd.honeycomb.v3po.translate.v3po.interfaces.InterfaceCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.VppApiCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.VppApiInvocationException;
import io.fd.honeycomb.v3po.translate.v3po.utils.V3poUtils;
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv4> id,
@Nonnull final Ipv4 dataAfter, @Nonnull final Context writeContext)
throws WriteFailedException {
- final Interface ifc = (Interface) writeContext.get(InterfaceCustomizer.IFC_AFTER_CTX);
-
try {
- setIpv4(id, ifc.getName(), dataAfter);
+ final String ifcName = id.firstKeyOf(Interface.class).getName();
+ setIpv4(id, ifcName, dataAfter);
} catch (VppApiInvocationException e) {
LOG.warn("Create of Ipv4 failed", e);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
@Nonnull final Ipv4 dataBefore, @Nonnull final Ipv4 dataAfter,
@Nonnull final Context writeContext)
throws WriteFailedException {
- final Interface ifcBefore = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
- final Interface ifcAfter = (Interface) writeContext.get(InterfaceCustomizer.IFC_BEFORE_CTX);
+ final String ifcName = id.firstKeyOf(Interface.class).getName();
// TODO handle update in a better way
try {
- setIpv4(id, ifcAfter.getName(), dataAfter);
+ setIpv4(id, ifcName, dataAfter);
} catch (VppApiInvocationException e) {
LOG.warn("Update of Ipv4 failed", e);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
id, builder, context);
final BridgeDomainKey key = id.firstKeyOf(id.getTargetType());
- // TODO find out if bd exists based on name and if not return
LOG.debug("vppstate.BridgeDomainCustomizer.readCurrentAttributes: key={}", key);
final int bdId = getVppApi().bridgeDomainIdFromName(key.getName());
LOG.debug("vppstate.BridgeDomainCustomizer.readCurrentAttributes: bdId={}", bdId);
final vppBridgeDomainDetails bridgeDomainDetails = getVppApi().getBridgeDomainDetails(bdId);
+ if(bridgeDomainDetails == null) {
+ LOG.debug("Bridge domain name={} does not exist", key.getName());
+ return;
+ }
logBridgeDomainDetails(bridgeDomainDetails);
builder.setName(key.getName());
import io.fd.honeycomb.v3po.translate.util.RWUtils;
import io.fd.honeycomb.v3po.translate.util.write.CloseableWriter;
import io.fd.honeycomb.v3po.translate.util.write.NoopWriterCustomizer;
-import io.fd.honeycomb.v3po.translate.util.write.ReflexiveChildWriterCustomizer;
+import io.fd.honeycomb.v3po.translate.util.write.ReflexiveAugmentWriterCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.interfaces.EthernetCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.interfaces.InterfaceCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.interfaces.L2Customizer;
import io.fd.honeycomb.v3po.translate.v3po.interfaces.RoutingCustomizer;
-import io.fd.honeycomb.v3po.translate.v3po.interfaces.VppInterfaceCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.interfaces.VxlanCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.interfaces.ip.Ipv4Customizer;
import io.fd.honeycomb.v3po.translate.v3po.interfaces.ip.Ipv6Customizer;
final List<ChildWriter<? extends Augmentation<Interface>>> ifcAugmentations = Lists.newArrayList();
ifcAugmentations.add(getVppIfcAugmentationWriter());
+ ifcAugmentations.add(getInterface1AugmentationWriter());
final ChildWriter<Interface> interfaceWriter = new CompositeListWriter<>(Interface.class,
RWUtils.<Interface>emptyChildWriterList(),
ifcAugmentations,
- new InterfaceCustomizer(getVppJapiIfcDependency()));
+ new InterfaceCustomizer(getVppJapiIfcDependency()),
+ // It's important that this customizer is handled in a postorder way, because you first have to handle child nodes
+ // e.g. Vxlan before setting other interface or vppInterfaceAugmentation leaves
+ TraversalType.POSTORDER);
final List<ChildWriter<? extends ChildOf<Interfaces>>> childWriters = new ArrayList<>();
childWriters.add(interfaceWriter);
interface1ChildWriters.add(ipv6Writer);
return new CompositeChildWriter<>(Interface1.class,
- interface1ChildWriters, new ReflexiveChildWriterCustomizer<Interface1>());
+ interface1ChildWriters, new ReflexiveAugmentWriterCustomizer<Interface1>());
}
private ChildWriter<VppInterfaceAugmentation> getVppIfcAugmentationWriter() {
final List<ChildWriter<? extends ChildOf<VppInterfaceAugmentation>>> vppIfcChildWriters = Lists.newArrayList();
// TODO what's the order here ?
- vppIfcChildWriters.add(ethernetWriter);
vppIfcChildWriters.add(vxlanWriter);
+ vppIfcChildWriters.add(ethernetWriter);
vppIfcChildWriters.add(l2Writer);
vppIfcChildWriters.add(routingWriter);
return new CompositeChildWriter<>(VppInterfaceAugmentation.class,
vppIfcChildWriters,
RWUtils.<VppInterfaceAugmentation>emptyAugWriterList(),
- new VppInterfaceCustomizer(getVppJapiIfcDependency()),
- // It's important that this customizer is handled in a postorder way, because you first have to handle child nodes
- // e.g. Vxlan before setting other interface or vppInterfaceAugmentation leaves
- TraversalType.POSTORDER);
+ new ReflexiveAugmentWriterCustomizer<VppInterfaceAugmentation>());
}
}
Code Review / hc2vpp.git / commitdiff