private final InstanceIdentifier<?> failedId;
/**
- * Constructs an WriteFailedException given data id and exception cause.
+ * Constructs an WriteFailedException given data id, exception detail message and exception cause.
*
* @param failedId instance identifier of the data object that could not be read
* @param cause the cause of read failure
- * @param message
+ * @param message the exception detail message
*/
public WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId,
@Nonnull final String message,
this.failedId = checkNotNull(failedId, "failedId should not be null");
}
+ /**
+ * Constructs an WriteFailedException given data id and exception cause.
+ *
+ * @param failedId instance identifier of the data object that could not be read
+ * @param cause the cause of read failure
+ */
+ public WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId,
+ @Nonnull final Throwable cause) {
+ super(cause);
+ this.failedId = checkNotNull(failedId, "failedId should not be null");
+ }
+
/**
* Returns id of the data object that could not be written.
*
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import java.util.concurrent.CompletionStage;
if (ic == null) { // TODO in case of update we should delete interconnection
LOG.trace("Interconnection is not set. Skipping");
} else if (ic instanceof XconnectBased) {
- setXconnectBasedL2(swIfIndex, ifcName, (XconnectBased) ic, writeContext, (byte) 1 /*enable*/);
+ setXconnectBasedL2(id, swIfIndex, ifcName, (XconnectBased) ic, writeContext, (byte) 1 /*enable*/);
} else if (ic instanceof BridgeBased) {
- setBridgeBasedL2(swIfIndex, ifcName, (BridgeBased) ic, writeContext, (byte) 1 /*enable*/);
+ setBridgeBasedL2(id, swIfIndex, ifcName, (BridgeBased) ic, writeContext, (byte) 1 /*enable*/);
} 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
if (ic == null) { // TODO in case of update we should delete interconnection
LOG.trace("Interconnection is not set. Skipping");
} else if (ic instanceof XconnectBased) {
- setXconnectBasedL2(swIfIndex, ifcName, (XconnectBased) ic, writeContext, (byte) 0 /*disable*/);
+ setXconnectBasedL2(id, swIfIndex, ifcName, (XconnectBased) ic, writeContext, (byte) 0 /*disable*/);
} else if (ic instanceof BridgeBased) {
- setBridgeBasedL2(swIfIndex, ifcName, (BridgeBased) ic, writeContext, (byte) 0 /*disable*/);
+ setBridgeBasedL2(id, swIfIndex, ifcName, (BridgeBased) ic, writeContext, (byte) 0 /*disable*/);
} else {
LOG.error("Unable to delete Interconnection of type {}", ic.getClass());
throw new WriteFailedException(id, "Unable to delete Interconnection of type " + ic.getClass());
}
}
- private void setBridgeBasedL2(final int swIfIndex, final String ifcName, final BridgeBased bb,
+ private void setBridgeBasedL2(final InstanceIdentifier<? extends DataObject> id, final int swIfIndex,
+ final String ifcName, final BridgeBased bb,
final WriteContext writeContext, final byte enabled)
- throws VppBaseCallException {
+ throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Setting bridge based interconnection(bridge-domain={}) for interface: {}", bb.getBridgeDomain(),
ifcName);
final CompletionStage<SwInterfaceSetL2BridgeReply> swInterfaceSetL2BridgeReplyCompletionStage = futureJvpp
.swInterfaceSetL2Bridge(getL2BridgeRequest(swIfIndex, bdId, shg, bvi, enabled));
- TranslateUtils.getReply(swInterfaceSetL2BridgeReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(swInterfaceSetL2BridgeReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Bridge based interconnection updated successfully for: {}, interconnection: {}", ifcName, bb);
}
return swInterfaceSetL2Bridge;
}
- private void setXconnectBasedL2(final int swIfIndex, final String ifcName, final XconnectBased ic,
+ private void setXconnectBasedL2(final InstanceIdentifier<? extends DataObject> id, final int swIfIndex,
+ final String ifcName, final XconnectBased ic,
final WriteContext writeContext, final byte enabled)
- throws VppBaseCallException {
+ throws VppBaseCallException, WriteTimeoutException {
String outSwIfName = ic.getXconnectOutgoingInterface();
LOG.debug("Setting xconnect based interconnection(outgoing ifc={}) for interface: {}", outSwIfName, ifcName);
final CompletionStage<SwInterfaceSetL2XconnectReply> swInterfaceSetL2XconnectReplyCompletionStage =
futureJvpp
.swInterfaceSetL2Xconnect(getL2XConnectRequest(swIfIndex, outSwIfIndex, enabled));
- TranslateUtils.getReply(swInterfaceSetL2XconnectReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(swInterfaceSetL2XconnectReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Xconnect based interconnection updated successfully for: {}, interconnection: {}", ifcName, ic);
}
import io.fd.honeycomb.v3po.translate.v3po.util.FutureJVppCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import java.util.List;
@Nonnull final Interface dataBefore,
@Nonnull final Interface dataAfter,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.UpdateFailedException {
+ throws WriteFailedException {
try {
updateInterface(id, dataBefore, dataAfter, writeContext);
private void setInterface(final InstanceIdentifier<Interface> id, final Interface swIf,
final WriteContext writeContext)
- throws VppBaseCallException {
+ throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Setting interface: {} to: {}", id, swIf);
- setInterfaceAttributes(swIf, swIf.getName(), writeContext);
+ setInterfaceAttributes(id, swIf, swIf.getName(), writeContext);
}
- private void setInterfaceAttributes(final Interface swIf, final String swIfName, final WriteContext writeContext)
- throws VppBaseCallException {
+ private void setInterfaceAttributes(final InstanceIdentifier<Interface> id, final Interface swIf,
+ final String swIfName, final WriteContext writeContext)
+ throws VppBaseCallException, WriteTimeoutException {
- setInterfaceFlags(swIfName, interfaceContext.getIndex(swIfName, writeContext.getMappingContext()),
+ setInterfaceFlags(id, swIfName, interfaceContext.getIndex(swIfName, writeContext.getMappingContext()),
swIf.isEnabled() ? (byte) 1 : (byte) 0);
}
private void updateInterface(final InstanceIdentifier<Interface> id,
final Interface dataBefore,
- final Interface dataAfter, final WriteContext writeContext) throws VppBaseCallException {
+ final Interface dataAfter, final WriteContext writeContext)
+ throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Updating interface:{} to: {}", id, dataAfter);
- setInterfaceAttributes(dataAfter, dataAfter.getName(), writeContext);
+ setInterfaceAttributes(id, dataAfter, dataAfter.getName(), writeContext);
}
- private void setInterfaceFlags(final String swIfName, final int swIfIndex, final byte enabled)
- throws VppBaseCallException {
+ private void setInterfaceFlags(final InstanceIdentifier<Interface> id, final String swIfName, final int swIfIndex,
+ final byte enabled)
+ throws VppBaseCallException, WriteTimeoutException {
final CompletionStage<SwInterfaceSetFlagsReply> swInterfaceSetFlagsReplyFuture = getFutureJVpp().swInterfaceSetFlags(
getSwInterfaceSetFlagsInput(swIfIndex, enabled, (byte) 0 /* deleted */));
LOG.debug("Updating interface flags for: {}, index: {}, enabled: {}", swIfName, swIfIndex, enabled);
- SwInterfaceSetFlagsReply reply = TranslateUtils.getReply(swInterfaceSetFlagsReplyFuture.toCompletableFuture());
- LOG.debug("Interface flags updated successfully for: {}, index: {}, enabled: {}, ctxId: {}",
- swIfName, swIfIndex, enabled, reply.context);
+ TranslateUtils.getReplyForWrite(swInterfaceSetFlagsReplyFuture.toCompletableFuture(), id);
+ LOG.debug("Interface flags updated successfully for: {}, index: {}, enabled: {}",
+ swIfName, swIfIndex, enabled);
}
private SwInterfaceSetFlags getSwInterfaceSetFlagsInput(final int swIfIndex, final byte enabled, final byte deleted) {
import io.fd.honeycomb.v3po.translate.v3po.util.SubInterfaceUtils;
import io.fd.honeycomb.v3po.translate.v3po.util.TagRewriteOperation;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import java.util.List;
@Override
public void writeCurrentAttributes(final InstanceIdentifier<Rewrite> id, final Rewrite dataAfter,
final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
final String subifName = getSubInterfaceName(id);
try {
- setTagRewrite(subifName, dataAfter, writeContext);
+ setTagRewrite(id, subifName, dataAfter, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to write interface {}(id=): {}", subifName, writeContext, dataAfter);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
Math.toIntExact(id.firstKeyOf(SubInterface.class).getIdentifier()));
}
- private void setTagRewrite(final String ifname, final Rewrite rewrite, final WriteContext writeContext)
- throws VppBaseCallException {
+ private void setTagRewrite(final InstanceIdentifier<Rewrite> id, final String ifname, final Rewrite rewrite,
+ final WriteContext writeContext)
+ throws VppBaseCallException, WriteTimeoutException {
final int swIfIndex = interfaceContext.getIndex(ifname, writeContext.getMappingContext());
LOG.debug("Setting tag rewrite for interface {}(id=): {}", ifname, swIfIndex, rewrite);
final CompletionStage<L2InterfaceVlanTagRewriteReply> replyCompletionStage =
getFutureJVpp().l2InterfaceVlanTagRewrite(getTagRewriteRequest(swIfIndex, rewrite));
- final L2InterfaceVlanTagRewriteReply reply =
- TranslateUtils.getReply(replyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(replyCompletionStage.toCompletableFuture(), id);
LOG.debug("Tag rewrite for interface {}(id=) set successfully: {}", ifname, swIfIndex, rewrite);
}
throws WriteFailedException {
final String subifName = getSubInterfaceName(id);
try {
- setTagRewrite(subifName, dataAfter, writeContext);
+ setTagRewrite(id, subifName, dataAfter, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to update interface {}(id=): {}", subifName, writeContext, dataAfter);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id,
@Nonnull final Rewrite dataBefore, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.DeleteFailedException {
+ throws WriteFailedException {
final String subifName = getSubInterfaceName(id);
try {
LOG.debug("Disabling tag rewrite for interface {}", subifName);
final Rewrite rewrite = new RewriteBuilder().build(); // rewrite without push and pops will cause delete
- setTagRewrite(subifName, rewrite, writeContext);
+ setTagRewrite(id, subifName, rewrite, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to delete interface {}(id=): {}", subifName, writeContext, dataBefore);
throw new WriteFailedException.DeleteFailedException(id, e);
import io.fd.honeycomb.v3po.translate.v3po.util.FutureJVppCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
@Override
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
final String ifName = id.firstKeyOf(Interface.class).getName();
try {
- setRouting(ifName, dataAfter, writeContext);
+ setRouting(id, ifName, dataAfter, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to set routing for interface: {}, {}, vxlan: {}", ifName, writeContext, dataAfter);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.UpdateFailedException {
+ throws WriteFailedException {
final String ifName = id.firstKeyOf(Interface.class).getName();
try {
// TODO handle updates properly
- setRouting(ifName, dataAfter, writeContext);
+ setRouting(id, ifName, dataAfter, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to update routing for interface: {}, {}, vxlan: {}", ifName, writeContext, dataAfter);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
// TODO implement delete
}
- private void setRouting(final String name, final Routing rt, final WriteContext writeContext) throws VppBaseCallException {
+ private void setRouting(final InstanceIdentifier<Routing> id, final String name, final Routing rt,
+ final WriteContext writeContext) throws VppBaseCallException, WriteTimeoutException {
final int swIfc = interfaceContext.getIndex(name, writeContext.getMappingContext());
LOG.debug("Setting routing for interface: {}, {}. Routing: {}", name, swIfc, rt);
if (vrfId != 0) {
final CompletionStage<SwInterfaceSetTableReply> swInterfaceSetTableReplyCompletionStage =
getFutureJVpp().swInterfaceSetTable(getInterfaceSetTableRequest(swIfc, (byte) 0, /* isIpv6 */ vrfId));
- final SwInterfaceSetTableReply reply =
- TranslateUtils.getReply(swInterfaceSetTableReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(swInterfaceSetTableReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Routing set successfully for interface: {}, {}, routing: {}", name, swIfc, rt);
}
}
import io.fd.honeycomb.v3po.translate.v3po.util.FutureJVppCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import java.util.List;
* Equivalent of invoking {@code vppclt create subif} command.
*/
public class SubInterfaceCustomizer extends FutureJVppCustomizer
- implements ListWriterCustomizer<SubInterface, SubInterfaceKey> {
+ implements ListWriterCustomizer<SubInterface, SubInterfaceKey> {
private static final Logger LOG = LoggerFactory.getLogger(SubInterfaceCustomizer.class);
private final NamingContext interfaceContext;
@Nonnull
@Override
public Optional<List<SubInterface>> extract(@Nonnull final InstanceIdentifier<SubInterface> currentId,
- @Nonnull final DataObject parentData) {
+ @Nonnull final DataObject parentData) {
return Optional.fromNullable(((SubInterfaces) parentData).getSubInterface());
}
@Override
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
+ final String superIfName = id.firstKeyOf(Interface.class).getName();
try {
- createSubInterface(id.firstKeyOf(Interface.class).getName(), dataAfter, writeContext);
+ createSubInterface(id, superIfName, dataAfter, writeContext);
} catch (VppBaseCallException e) {
- LOG.warn("Failed to create sub interface for: {}, subInterface: {}", id.firstKeyOf(Interface.class).getName(), dataAfter);
+ LOG.warn("Failed to create sub interface for: {}, subInterface: {}", superIfName, dataAfter);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
}
}
- private void createSubInterface(@Nonnull final String superIfName,
+ private void createSubInterface(final InstanceIdentifier<SubInterface> id, @Nonnull final String superIfName,
@Nonnull final SubInterface subInterface,
- final WriteContext writeContext) throws VppBaseCallException {
+ final WriteContext writeContext) throws VppBaseCallException,
+ WriteTimeoutException {
final int superIfIndex = interfaceContext.getIndex(superIfName, writeContext.getMappingContext());
final CompletionStage<CreateSubifReply> createSubifReplyCompletionStage =
getFutureJVpp().createSubif(getCreateSubifRequest(subInterface, superIfIndex));
final CreateSubifReply reply =
- TranslateUtils.getReply(createSubifReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(createSubifReplyCompletionStage.toCompletableFuture(), id);
- setInterfaceState(reply.swIfIndex, booleanToByte(subInterface.isEnabled()));
+ setInterfaceState(id, reply.swIfIndex, booleanToByte(subInterface.isEnabled()));
interfaceContext.addName(reply.swIfIndex,
getSubInterfaceName(superIfName, Math.toIntExact(subInterface.getIdentifier())),
writeContext.getMappingContext());
final MatchType matchType = subInterface.getMatch().getMatchType(); // todo match should be mandatory
request.exactMatch =
- booleanToByte(matchType instanceof VlanTagged && ((VlanTagged) matchType).isMatchExactTags());
+ booleanToByte(matchType instanceof VlanTagged && ((VlanTagged) matchType).isMatchExactTags());
request.defaultSub = booleanToByte(matchType instanceof Default);
if (numberOfTags > 0) {
public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.UpdateFailedException {
+ throws WriteFailedException {
if (Objects.equals(dataBefore.isEnabled(), dataAfter.isEnabled())) {
LOG.debug("No state update will be performed. Ignoring config");
return; // TODO shouldn't we throw exception here (if there will be dedicated L2 customizer)?
}
final String subIfaceName = getSubInterfaceName(id.firstKeyOf(Interface.class).getName(),
- Math.toIntExact(dataAfter.getIdentifier()));
+ Math.toIntExact(dataAfter.getIdentifier()));
try {
- setInterfaceState(interfaceContext.getIndex(subIfaceName, writeContext.getMappingContext()),
- booleanToByte(dataAfter.isEnabled()));
+ setInterfaceState(id, interfaceContext.getIndex(subIfaceName, writeContext.getMappingContext()),
+ booleanToByte(dataAfter.isEnabled()));
} catch (VppBaseCallException e) {
LOG.warn("Failed to update interface state for: interface if={}, enabled: {}",
- subIfaceName, booleanToByte(dataAfter.isEnabled()));
+ subIfaceName, booleanToByte(dataAfter.isEnabled()));
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
}
}
- private void setInterfaceState(final int swIfIndex, final byte enabled) throws VppBaseCallException {
+ private void setInterfaceState(final InstanceIdentifier<SubInterface> id, final int swIfIndex, final byte enabled)
+ throws VppBaseCallException, WriteTimeoutException {
final SwInterfaceSetFlags swInterfaceSetFlags = new SwInterfaceSetFlags();
swInterfaceSetFlags.swIfIndex = swIfIndex;
swInterfaceSetFlags.adminUpDown = enabled;
final CompletionStage<SwInterfaceSetFlagsReply> swInterfaceSetFlagsReplyFuture =
- getFutureJVpp().swInterfaceSetFlags(swInterfaceSetFlags);
+ getFutureJVpp().swInterfaceSetFlags(swInterfaceSetFlags);
LOG.debug("Updating interface state for interface if={}, enabled: {}", swIfIndex, enabled);
- SwInterfaceSetFlagsReply reply = TranslateUtils.getReply(swInterfaceSetFlagsReplyFuture.toCompletableFuture());
+ SwInterfaceSetFlagsReply reply =
+ TranslateUtils.getReplyForWrite(swInterfaceSetFlagsReplyFuture.toCompletableFuture(), id);
LOG.debug("Interface state updated successfully for interface index: {}, enabled: {}, ctxId: {}",
swIfIndex, enabled, reply.context);
}
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataBefore,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.DeleteFailedException {
+ throws WriteFailedException.DeleteFailedException {
throw new UnsupportedOperationException("Sub interface delete is not supported");
}
}
import io.fd.honeycomb.v3po.translate.v3po.util.AbstractInterfaceTypeCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
@Override
protected final void writeInterface(@Nonnull final InstanceIdentifier<Tap> id, @Nonnull final Tap dataAfter,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
final String ifcName = id.firstKeyOf(Interface.class).getName();
try {
- createTap(ifcName, dataAfter, writeContext);
+ createTap(id, ifcName, dataAfter, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to set tap interface: {}, tap: {}", ifcName, dataAfter, e);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
@Override
public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Tap> id, @Nonnull final Tap dataBefore,
@Nonnull final Tap dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.UpdateFailedException {
+ throws WriteFailedException {
final String ifcName = id.firstKeyOf(Interface.class).getName();
final int index;
}
try {
- modifyTap(ifcName, index, dataAfter);
+ modifyTap(id, ifcName, index, dataAfter);
} catch (VppBaseCallException e) {
LOG.warn("Failed to set tap interface: {}, tap: {}", ifcName, dataAfter, e);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Tap> id, @Nonnull final Tap dataBefore,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.DeleteFailedException {
+ throws WriteFailedException {
final String ifcName = id.firstKeyOf(Interface.class).getName();
final int index;
}
try {
- deleteTap(ifcName, index, dataBefore, writeContext);
+ deleteTap(id, ifcName, index, dataBefore, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to delete tap interface: {}, tap: {}", ifcName, dataBefore.getTapName(), e);
throw new WriteFailedException.DeleteFailedException(id, e);
}
}
- private void createTap(final String swIfName, final Tap tap, final WriteContext writeContext) throws VppBaseCallException {
+ private void createTap(final InstanceIdentifier<Tap> id, final String swIfName, final Tap tap,
+ final WriteContext writeContext) throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Setting tap interface: {}. Tap: {}", swIfName, tap);
final CompletionStage<TapConnectReply> tapConnectFuture =
getFutureJVpp().tapConnect(getTapConnectRequest(tap.getTapName(), tap.getMac(), tap.getDeviceInstance()));
final TapConnectReply reply =
- TranslateUtils.getReply(tapConnectFuture.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(tapConnectFuture.toCompletableFuture(), id);
LOG.debug("Tap set successfully for: {}, tap: {}", swIfName, tap);
// Add new interface to our interface context
interfaceContext.addName(reply.swIfIndex, swIfName, writeContext.getMappingContext());
}
- private void modifyTap(final String swIfName, final int index, final Tap tap) throws VppBaseCallException {
+ private void modifyTap(final InstanceIdentifier<Tap> id, final String swIfName, final int index, final Tap tap)
+ throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Modifying tap interface: {}. Tap: {}", swIfName, tap);
final CompletionStage<TapModifyReply> vxlanAddDelTunnelReplyCompletionStage =
getFutureJVpp().tapModify(getTapModifyRequest(tap.getTapName(), index, tap.getMac(), tap.getDeviceInstance()));
- final TapModifyReply reply =
- TranslateUtils.getReply(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Tap modified successfully for: {}, tap: {}", swIfName, tap);
}
- private void deleteTap(final String swIfName, final int index, final Tap dataBefore,
+ private void deleteTap(final InstanceIdentifier<Tap> id, final String swIfName, final int index,
+ final Tap dataBefore,
final WriteContext writeContext)
- throws VppBaseCallException {
+ throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Deleting tap interface: {}. Tap: {}", swIfName, dataBefore);
final CompletionStage<TapDeleteReply> vxlanAddDelTunnelReplyCompletionStage =
getFutureJVpp().tapDelete(getTapDeleteRequest(index));
- final TapDeleteReply reply =
- TranslateUtils.getReply(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Tap deleted successfully for: {}, tap: {}", swIfName, dataBefore);
// Remove deleted interface from interface context
interfaceContext.removeName(swIfName, writeContext.getMappingContext());
import io.fd.honeycomb.v3po.translate.v3po.util.AbstractInterfaceTypeCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
@Override
protected final void writeInterface(@Nonnull final InstanceIdentifier<VhostUser> id,
@Nonnull final VhostUser dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
final String swIfName = id.firstKeyOf(Interface.class).getName();
try {
- createVhostUserIf(swIfName, dataAfter, writeContext);
+ createVhostUserIf(id, swIfName, dataAfter, writeContext);
} catch (VppBaseCallException | IllegalInterfaceTypeException e) {
LOG.debug("Failed to create vhost user interface: {}, vhostUser: {}", swIfName, dataAfter);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
}
}
- private void createVhostUserIf(final String swIfName, final VhostUser vhostUser, final WriteContext writeContext) throws VppBaseCallException {
+ private void createVhostUserIf(final InstanceIdentifier<VhostUser> id, final String swIfName,
+ final VhostUser vhostUser, final WriteContext writeContext)
+ throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Creating vhost user interface: name={}, vhostUser={}", swIfName, vhostUser);
final CompletionStage<CreateVhostUserIfReply> createVhostUserIfReplyCompletionStage =
getFutureJVpp().createVhostUserIf(getCreateVhostUserIfRequest(vhostUser));
final CreateVhostUserIfReply reply =
- TranslateUtils.getReply(createVhostUserIfReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(createVhostUserIfReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Vhost user interface created successfully for: {}, vhostUser: {}", swIfName, vhostUser);
// Add new interface to our interface context
interfaceContext.addName(reply.swIfIndex, swIfName, writeContext.getMappingContext());
public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id,
@Nonnull final VhostUser dataBefore, @Nonnull final VhostUser dataAfter,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.UpdateFailedException {
+ throws WriteFailedException {
final String swIfName = id.firstKeyOf(Interface.class).getName();
try {
- modifyVhostUserIf(swIfName, dataAfter, writeContext);
+ modifyVhostUserIf(id, swIfName, dataAfter, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to update vhost user interface: {}, vhostUser: {}", swIfName, dataAfter);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
}
}
- private void modifyVhostUserIf(final String swIfName, final VhostUser vhostUser, final WriteContext writeContext) throws VppBaseCallException {
+ private void modifyVhostUserIf(final InstanceIdentifier<VhostUser> id, final String swIfName,
+ final VhostUser vhostUser, final WriteContext writeContext)
+ throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Updating vhost user interface: name={}, vhostUser={}", swIfName, vhostUser);
final CompletionStage<ModifyVhostUserIfReply> modifyVhostUserIfReplyCompletionStage =
getFutureJVpp()
.modifyVhostUserIf(getModifyVhostUserIfRequest(vhostUser, interfaceContext.getIndex(swIfName, writeContext.getMappingContext())));
- final ModifyVhostUserIfReply reply =
- TranslateUtils.getReply(modifyVhostUserIfReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(modifyVhostUserIfReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Vhost user interface updated successfully for: {}, vhostUser: {}", swIfName, vhostUser);
}
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VhostUser> id,
@Nonnull final VhostUser dataBefore, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.DeleteFailedException {
+ throws WriteFailedException {
final String swIfName = id.firstKeyOf(Interface.class).getName();
try {
- deleteVhostUserIf(swIfName, dataBefore, writeContext);
+ deleteVhostUserIf(id, swIfName, dataBefore, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to delete vhost user interface: {}, vhostUser: {}", swIfName, dataBefore);
throw new WriteFailedException.DeleteFailedException(id, e);
}
}
- private void deleteVhostUserIf(final String swIfName, final VhostUser vhostUser, final WriteContext writeContext) throws VppBaseCallException {
+ private void deleteVhostUserIf(final InstanceIdentifier<VhostUser> id, final String swIfName,
+ final VhostUser vhostUser, final WriteContext writeContext)
+ throws VppBaseCallException, WriteTimeoutException {
LOG.debug("Deleting vhost user interface: name={}, vhostUser={}", swIfName, vhostUser);
final CompletionStage<DeleteVhostUserIfReply> deleteVhostUserIfReplyCompletionStage =
getFutureJVpp().deleteVhostUserIf(getDeleteVhostUserIfRequest(interfaceContext.getIndex(swIfName, writeContext.getMappingContext())));
- final DeleteVhostUserIfReply reply =
- TranslateUtils.getReply(deleteVhostUserIfReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(deleteVhostUserIfReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Vhost user interface deleted successfully for: {}, vhostUser: {}", swIfName, vhostUser);
// Remove interface from our interface context
interfaceContext.removeName(swIfName, writeContext.getMappingContext());
package io.fd.honeycomb.v3po.translate.v3po.interfaces;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Optional;
import com.google.common.net.InetAddresses;
import io.fd.honeycomb.v3po.translate.v3po.util.AbstractInterfaceTypeCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
+import java.net.InetAddress;
+import java.util.concurrent.CompletionStage;
+import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.annotation.Nonnull;
-import java.net.InetAddress;
-import java.util.concurrent.CompletionStage;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
// TODO extract common code from all Interface type specific writer customizers into a superclass
public class VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> {
@Override
protected final void writeInterface(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataAfter,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
final String swIfName = id.firstKeyOf(Interface.class).getName();
try {
- createVxlanTunnel(swIfName, dataAfter, writeContext);
+ createVxlanTunnel(id, swIfName, dataAfter, writeContext);
} catch (VppBaseCallException | IllegalInterfaceTypeException e) {
LOG.debug("Failed to set vxlan tunnel for interface: {}, vxlan: {}", swIfName, dataAfter);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.DeleteFailedException {
+ throws WriteFailedException {
final String swIfName = id.firstKeyOf(Interface.class).getName();
try {
- deleteVxlanTunnel(swIfName, dataBefore, writeContext);
+ deleteVxlanTunnel(id, swIfName, dataBefore, writeContext);
} catch (VppBaseCallException e) {
LOG.debug("Failed to delete vxlan tunnel for interface: {}, vxlan: {}", swIfName, dataBefore);
throw new WriteFailedException.DeleteFailedException(id, e);
}
}
- private void createVxlanTunnel(final String swIfName, final Vxlan vxlan, final WriteContext writeContext) throws VppBaseCallException {
+ private void createVxlanTunnel(final InstanceIdentifier<Vxlan> id, final String swIfName, final Vxlan vxlan,
+ final WriteContext writeContext) throws VppBaseCallException, WriteTimeoutException {
final byte isIpv6 = (byte) (isIpv6(vxlan) ? 1 : 0);
final InetAddress srcAddress = InetAddresses.forString(getAddressString(vxlan.getSrc()));
final InetAddress dstAddress = InetAddresses.forString(getAddressString(vxlan.getDst()));
dstAddress.getAddress(), encapVrfId, -1, vni, isIpv6));
final VxlanAddDelTunnelReply reply =
- TranslateUtils.getReply(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Vxlan tunnel set successfully for: {}, vxlan: {}", swIfName, vxlan);
if(interfaceContext.containsName(reply.swIfIndex, writeContext.getMappingContext())) {
// VPP keeps vxlan tunnels present even after they are delete(reserving ID for next tunnel)
return addr.getIpv4Address() == null ? addr.getIpv6Address().getValue() : addr.getIpv4Address().getValue();
}
- private void deleteVxlanTunnel(final String swIfName, final Vxlan vxlan, final WriteContext writeContext) throws VppBaseCallException {
+ private void deleteVxlanTunnel(final InstanceIdentifier<Vxlan> id, final String swIfName, final Vxlan vxlan,
+ final WriteContext writeContext) throws VppBaseCallException, WriteTimeoutException {
final byte isIpv6 = (byte) (isIpv6(vxlan) ? 1 : 0);
final InetAddress srcAddress = InetAddresses.forString(getAddressString(vxlan.getSrc()));
final InetAddress dstAddress = InetAddresses.forString(getAddressString(vxlan.getDst()));
getFutureJVpp().vxlanAddDelTunnel(getVxlanTunnelRequest((byte) 0 /* is add */, srcAddress.getAddress(),
dstAddress.getAddress(), encapVrfId, -1, vni, isIpv6));
- final VxlanAddDelTunnelReply reply =
- TranslateUtils.getReply(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(vxlanAddDelTunnelReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Vxlan tunnel deleted successfully for: {}, vxlan: {}", swIfName, vxlan);
// Remove interface from our interface context
interfaceContext.removeName(swIfName, writeContext.getMappingContext());
import io.fd.honeycomb.v3po.translate.v3po.util.AbstractInterfaceTypeCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import java.net.InetAddress;
@Override
protected final void writeInterface(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataAfter,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
final String swIfName = id.firstKeyOf(Interface.class).getName();
try {
- createVxlanGpeTunnel(swIfName, dataAfter, writeContext);
+ createVxlanGpeTunnel(id, swIfName, dataAfter, writeContext);
} catch (VppBaseCallException | IllegalInterfaceTypeException e) {
LOG.warn("Failed to set VxlanGpe tunnel for interface: {}, VxlanGpe: {}", swIfName, dataAfter);
throw new WriteFailedException.CreateFailedException(id, dataAfter, e);
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VxlanGpe> id, @Nonnull final VxlanGpe dataBefore,
@Nonnull final WriteContext writeContext)
- throws WriteFailedException.DeleteFailedException {
+ throws WriteFailedException {
final String swIfName = id.firstKeyOf(Interface.class).getName();
try {
- deleteVxlanGpeTunnel(swIfName, dataBefore, writeContext);
+ deleteVxlanGpeTunnel(id, swIfName, dataBefore, writeContext);
} catch (VppBaseCallException e) {
LOG.warn("Failed to delete VxlanGpe tunnel for interface: {}, VxlanGpe: {}", swIfName, dataBefore);
throw new WriteFailedException.DeleteFailedException(id, e);
}
}
- private void createVxlanGpeTunnel(final String swIfName, final VxlanGpe VxlanGpe, final WriteContext writeContext) throws VppBaseCallException {
+ private void createVxlanGpeTunnel(final InstanceIdentifier<VxlanGpe> id, final String swIfName,
+ final VxlanGpe VxlanGpe, final WriteContext writeContext)
+ throws VppBaseCallException, WriteTimeoutException {
final byte isIpv6 = (byte) (isIpv6(VxlanGpe) ? 1 : 0);
final InetAddress Local = InetAddresses.forString(getAddressString(VxlanGpe.getLocal()));
final InetAddress Remote = InetAddresses.forString(getAddressString(VxlanGpe.getRemote()));
Remote.getAddress(), vni, protocol, encapVrfId, decapVrfId, isIpv6));
final VxlanGpeAddDelTunnelReply reply =
- TranslateUtils.getReply(VxlanGpeAddDelTunnelReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(VxlanGpeAddDelTunnelReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("VxlanGpe tunnel set successfully for: {}, VxlanGpe: {}", swIfName, VxlanGpe);
if(interfaceContext.containsName(reply.swIfIndex, writeContext.getMappingContext())) {
final String formerName = interfaceContext.getName(reply.swIfIndex, writeContext.getMappingContext());
return addr.getIpv4Address() == null ? addr.getIpv6Address().getValue() : addr.getIpv4Address().getValue();
}
- private void deleteVxlanGpeTunnel(final String swIfName, final VxlanGpe VxlanGpe, final WriteContext writeContext) throws VppBaseCallException {
+ private void deleteVxlanGpeTunnel(final InstanceIdentifier<VxlanGpe> id, final String swIfName,
+ final VxlanGpe VxlanGpe, final WriteContext writeContext)
+ throws VppBaseCallException, WriteTimeoutException {
final byte isIpv6 = (byte) (isIpv6(VxlanGpe) ? 1 : 0);
final InetAddress local = InetAddresses.forString(getAddressString(VxlanGpe.getLocal()));
final InetAddress remote = InetAddresses.forString(getAddressString(VxlanGpe.getRemote()));
getFutureJVpp().vxlanGpeAddDelTunnel(getVxlanGpeTunnelRequest((byte) 0 /* is delete */, local.getAddress(),
remote.getAddress(), vni, protocol, encapVrfId, decapVrfId, isIpv6));
- final VxlanGpeAddDelTunnelReply reply =
- TranslateUtils.getReply(VxlanGpeAddDelTunnelReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(VxlanGpeAddDelTunnelReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("VxlanGpe tunnel deleted successfully for: {}, VxlanGpe: {}", swIfName, VxlanGpe);
// Remove interface from our interface context
interfaceContext.removeName(swIfName, writeContext.getMappingContext());
getSwInterfaceAddDelAddressRequest(swIfc, TranslateUtils.booleanToByte(add) /* isAdd */,
(byte) 0 /* isIpv6 */, (byte) 0 /* delAll */, plen.byteValue(), addr));
- TranslateUtils.getReply(swInterfaceAddDelAddressReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(swInterfaceAddDelAddressReplyCompletionStage.toCompletableFuture(), id);
LOG.debug("Subnet(prefix-length) set successfully for interface: {}, {}, Subnet: {}, Address: {}", name,
swIfc, subnet, address);
final CompletableFuture<BridgeDomainDetailsReplyDump> bdCompletableFuture =
futureJvpp.bridgeDomainSwIfDump(request).toCompletableFuture();
- return TranslateUtils.getReply(bdCompletableFuture);
+ return TranslateUtils.getReplyForRead(bdCompletableFuture, id);
} catch (VppBaseCallException e) {
throw new ReadFailedException(id, e);
}
final CompletableFuture<SwInterfaceDetailsReplyDump> swInterfaceDetailsReplyDumpCompletableFuture =
getFutureJVpp().swInterfaceDump(request).toCompletableFuture();
final SwInterfaceDetailsReplyDump ifaces =
- TranslateUtils.getReply(swInterfaceDetailsReplyDumpCompletableFuture);
+ TranslateUtils.getReplyForRead(swInterfaceDetailsReplyDumpCompletableFuture, id);
if (null == ifaces || null == ifaces.swInterfaceDetails) {
LOG.debug("No interfaces for :{} found in VPP", id);
return allInterfaces.get(index);
}
- SwInterfaceDetailsReplyDump ifaces = null;
+ SwInterfaceDetailsReplyDump ifaces;
try {
CompletionStage<SwInterfaceDetailsReplyDump> requestFuture = futureJvpp.swInterfaceDump(request);
- ifaces = TranslateUtils.getReply(requestFuture.toCompletableFuture());
+ ifaces = TranslateUtils.getReplyForRead(requestFuture.toCompletableFuture(), id);
if (null == ifaces || null == ifaces.swInterfaceDetails || ifaces.swInterfaceDetails.isEmpty()) {
request.nameFilterValid = 0;
// Or else just perform full dump and do inefficient filtering
requestFuture = futureJvpp.swInterfaceDump(request);
- ifaces = TranslateUtils.getReply(requestFuture.toCompletableFuture());
+ ifaces = TranslateUtils.getReplyForRead(requestFuture.toCompletableFuture(), id);
// Update the cache
allInterfaces.clear();
final CompletableFuture<SwInterfaceDetailsReplyDump> swInterfaceDetailsReplyDumpCompletableFuture =
getFutureJVpp().swInterfaceDump(request).toCompletableFuture();
final SwInterfaceDetailsReplyDump ifaces =
- TranslateUtils.getReply(swInterfaceDetailsReplyDumpCompletableFuture);
+ TranslateUtils.getReplyForRead(swInterfaceDetailsReplyDumpCompletableFuture, id);
if (null == ifaces || null == ifaces.swInterfaceDetails) {
LOG.warn("Looking for sub-interfaces, but no interfaces found in VPP");
final CompletionStage<SwInterfaceTapDetailsReplyDump> swInterfaceTapDetailsReplyDumpCompletionStage =
getFutureJVpp().swInterfaceTapDump(request);
final SwInterfaceTapDetailsReplyDump reply =
- TranslateUtils.getReply(swInterfaceTapDetailsReplyDumpCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForRead(swInterfaceTapDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
if(null == reply || null == reply.swInterfaceTapDetails) {
mappedTaps = Collections.emptyMap();
final CompletionStage<SwInterfaceVhostUserDetailsReplyDump> swInterfaceVhostUserDetailsReplyDumpCompletionStage =
getFutureJVpp().swInterfaceVhostUserDump(request);
final SwInterfaceVhostUserDetailsReplyDump reply =
- TranslateUtils.getReply(swInterfaceVhostUserDetailsReplyDumpCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForRead(swInterfaceVhostUserDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
if(null == reply || null == reply.swInterfaceVhostUserDetails) {
mappedVhostUsers = Collections.emptyMap();
final CompletionStage<VxlanTunnelDetailsReplyDump> swInterfaceVxlanDetailsReplyDumpCompletionStage =
getFutureJVpp().vxlanTunnelDump(request);
final VxlanTunnelDetailsReplyDump reply =
- TranslateUtils.getReply(swInterfaceVxlanDetailsReplyDumpCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForRead(swInterfaceVxlanDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
// VPP keeps vxlan tunnel interfaces even after they were deleted (optimization)
// However there ar no longer any vxlan tunnel specific fields assigned to it and this call
final CompletionStage<VxlanGpeTunnelDetailsReplyDump> swInterfaceVxlanGpeDetailsReplyDumpCompletionStage =
getFutureJVpp().vxlanGpeTunnelDump(request);
final VxlanGpeTunnelDetailsReplyDump reply =
- TranslateUtils.getReply(swInterfaceVxlanGpeDetailsReplyDumpCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForRead(swInterfaceVxlanGpeDetailsReplyDumpCompletionStage.toCompletableFuture(), id);
// VPP keeps VxlanGpe tunnel interfaces even after they were deleted (optimization)
// However there are no longer any VxlanGpe tunnel specific fields assigned to it and this call
import io.fd.honeycomb.v3po.translate.util.RWUtils;
import io.fd.honeycomb.v3po.translate.v3po.util.FutureJVppCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.v3po.translate.v3po.util.ReadTimeoutException;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
import java.util.Collections;
import java.util.List;
private Optional<IpAddressDetailsReplyDump> dumpAddressFromOperationalData(final InstanceIdentifier<Address> id,
final MappingContext mappingContext)
- throws VppBaseCallException {
+ throws VppBaseCallException, ReadTimeoutException {
LOG.debug("Dumping from operational data...");
final IpAddressDump dumpRequest = new IpAddressDump();
dumpRequest.isIpv6 = 0;
dumpRequest.swIfIndex = interfaceContext.getIndex(id.firstKeyOf(Interface.class).getName(), mappingContext);
return Optional.fromNullable(
- TranslateUtils.getReply(getFutureJVpp().ipAddressDump(dumpRequest).toCompletableFuture()));
+ TranslateUtils.getReplyForRead(getFutureJVpp().ipAddressDump(dumpRequest).toCompletableFuture(), id));
}
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.CompletionStage;
+import java.util.concurrent.TimeoutException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.InterfaceStatus;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.openvpp.jvpp.VppBaseCallException;
-import org.openvpp.jvpp.VppInvocationException;
import org.openvpp.jvpp.dto.SwInterfaceSetFlagsNotification;
import org.openvpp.jvpp.dto.WantInterfaceEvents;
import org.openvpp.jvpp.dto.WantInterfaceEventsReply;
try {
wantInterfaceEventsReplyCompletionStage = jvpp.wantInterfaceEvents(wantInterfaceEvents);
TranslateUtils.getReply(wantInterfaceEventsReplyCompletionStage.toCompletableFuture());
- } catch (VppBaseCallException e) {
+ } catch (VppBaseCallException | TimeoutException e) {
LOG.warn("Unable to {} interface notifications", enableDisable == 1 ? "enable" : "disable", e);
throw new IllegalStateException("Unable to control interface notifications", e);
}
import io.fd.honeycomb.v3po.translate.v3po.util.FutureJVppCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import java.util.List;
return Optional.fromNullable(((BridgeDomains) parentData).getBridgeDomain());
}
- private BridgeDomainAddDelReply addOrUpdateBridgeDomain(final int bdId, @Nonnull final BridgeDomain bd)
- throws VppBaseCallException {
+ private BridgeDomainAddDelReply addOrUpdateBridgeDomain(@Nonnull final InstanceIdentifier<BridgeDomain> id,
+ final int bdId, @Nonnull final BridgeDomain bd)
+ throws VppBaseCallException, WriteTimeoutException {
final BridgeDomainAddDelReply reply;
final BridgeDomainAddDel request = new BridgeDomainAddDel();
request.bdId = bdId;
request.arpTerm = booleanToByte(bd.isArpTermination());
request.isAdd = ADD_OR_UPDATE_BD;
- reply = TranslateUtils.getReply(getFutureJVpp().bridgeDomainAddDel(request).toCompletableFuture());
+ reply = TranslateUtils.getReplyForWrite(getFutureJVpp().bridgeDomainAddDel(request).toCompletableFuture(), id);
LOG.debug("Bridge domain {} (id={}) add/update successful", bd.getName(), bdId);
return reply;
}
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomain> id,
@Nonnull final BridgeDomain dataBefore,
@Nonnull final WriteContext ctx)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
LOG.debug("writeCurrentAttributes: id={}, current={}, ctx={}", id, dataBefore, ctx);
final String bdName = dataBefore.getName();
index++;
}
}
- addOrUpdateBridgeDomain(index, dataBefore);
+ addOrUpdateBridgeDomain(id, index, dataBefore);
bdContext.addName(index, bdName, ctx.getMappingContext());
} catch (VppBaseCallException e) {
LOG.warn("Failed to create bridge domain", e);
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomain> id,
@Nonnull final BridgeDomain dataBefore,
@Nonnull final WriteContext ctx)
- throws WriteFailedException.DeleteFailedException {
+ throws WriteFailedException {
LOG.debug("deleteCurrentAttributes: id={}, dataBefore={}, ctx={}", id, dataBefore, ctx);
final String bdName = id.firstKeyOf(BridgeDomain.class).getName();
int bdId = bdContext.getIndex(bdName, ctx.getMappingContext());
final BridgeDomainAddDel request = new BridgeDomainAddDel();
request.bdId = bdId;
- TranslateUtils.getReply(getFutureJVpp().bridgeDomainAddDel(request).toCompletableFuture());
+ TranslateUtils.getReplyForWrite(getFutureJVpp().bridgeDomainAddDel(request).toCompletableFuture(), id);
LOG.debug("Bridge domain {} (id={}) deleted successfully", bdName, bdId);
} catch (VppBaseCallException e) {
LOG.warn("Bridge domain {} (id={}) delete failed", bdName, bdId);
public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomain> id,
@Nonnull final BridgeDomain dataBefore, @Nonnull final BridgeDomain dataAfter,
@Nonnull final WriteContext ctx)
- throws WriteFailedException.UpdateFailedException {
+ throws WriteFailedException {
LOG.debug("updateCurrentAttributes: id={}, dataBefore={}, dataAfter={}, ctx={}", id, dataBefore, dataAfter,
ctx);
"BridgeDomain name changed. It should be deleted and then created.");
try {
- addOrUpdateBridgeDomain(bdContext.getIndex(bdName, ctx.getMappingContext()), dataAfter);
+ addOrUpdateBridgeDomain(id, bdContext.getIndex(bdName, ctx.getMappingContext()), dataAfter);
} catch (VppBaseCallException e) {
LOG.warn("Failed to create bridge domain", e);
throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e);
import io.fd.honeycomb.v3po.translate.v3po.util.FutureJVppCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.v3po.translate.v3po.util.WriteTimeoutException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
import java.util.List;
@Override
public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id,
@Nonnull final L2FibEntry dataAfter, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException {
+ throws WriteFailedException {
try {
LOG.debug("Creating L2 FIB entry: {} {}", id, dataAfter);
l2FibAddDel(id, dataAfter, writeContext, true);
@Override
public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2FibEntry> id,
@Nonnull final L2FibEntry dataBefore, @Nonnull final WriteContext writeContext)
- throws WriteFailedException.DeleteFailedException {
+ throws WriteFailedException {
try {
LOG.debug("Deleting L2 FIB entry: {} {}", id, dataBefore);
l2FibAddDel(id, dataBefore, writeContext, false);
}
private void l2FibAddDel(@Nonnull final InstanceIdentifier<L2FibEntry> id, @Nonnull final L2FibEntry entry,
- final WriteContext writeContext, boolean isAdd) throws VppBaseCallException {
+ final WriteContext writeContext, boolean isAdd)
+ throws VppBaseCallException, WriteTimeoutException {
final String bdName = id.firstKeyOf(BridgeDomain.class).getName();
final int bdId = bdContext.getIndex(bdName, writeContext.getMappingContext());
final CompletionStage<L2FibAddDelReply> l2FibAddDelReplyCompletionStage =
getFutureJVpp().l2FibAddDel(l2FibRequest);
- TranslateUtils.getReply(l2FibAddDelReplyCompletionStage.toCompletableFuture());
+ TranslateUtils.getReplyForWrite(l2FibAddDelReplyCompletionStage.toCompletableFuture(), id);
}
private L2FibAddDel createL2FibRequest(final L2FibEntry entry, final int bdId, final int swIfIndex, boolean isAdd) {
import io.fd.honeycomb.v3po.translate.util.RWUtils;
import io.fd.honeycomb.v3po.translate.v3po.util.FutureJVppCustomizer;
import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.v3po.translate.v3po.util.ReadTimeoutException;
import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
import java.util.Collections;
import java.util.List;
try {
// TODO use cached l2FibTable
- final L2FibTableEntry entry = dumpL2Fibs(bdId).stream().filter(e -> key.getPhysAddress()
+ final L2FibTableEntry entry = dumpL2Fibs(id, bdId).stream().filter(e -> key.getPhysAddress()
.equals(new PhysAddress(vppPhysAddrToYang(Longs.toByteArray(e.mac), 2))))
.collect(SINGLE_ITEM_COLLECTOR);
}
@Nonnull
- private List<L2FibTableEntry> dumpL2Fibs(final int bdId) throws VppBaseCallException {
+ private List<L2FibTableEntry> dumpL2Fibs(final InstanceIdentifier<L2FibEntry> id, final int bdId)
+ throws VppBaseCallException, ReadTimeoutException {
final L2FibTableDump l2FibRequest = new L2FibTableDump();
l2FibRequest.bdId = bdId;
final CompletableFuture<L2FibTableEntryReplyDump> l2FibTableDumpCompletableFuture =
getFutureJVpp().l2FibTableDump(l2FibRequest).toCompletableFuture();
- final L2FibTableEntryReplyDump dump = TranslateUtils.getReply(l2FibTableDumpCompletableFuture);
+ final L2FibTableEntryReplyDump dump = TranslateUtils.getReplyForRead(l2FibTableDumpCompletableFuture, id);
if (null == dump || null == dump.l2FibTableEntry) {
return Collections.emptyList();
LOG.debug("Reading L2 FIB for bridge domain {} (bdId={})", bridgeDomainKey, bdId);
try {
- return dumpL2Fibs(bdId).stream()
+ return dumpL2Fibs(id, bdId).stream()
.map(entry -> new L2FibEntryKey(new PhysAddress(vppPhysAddrToYang(Longs.toByteArray(entry.mac), 2)))
).collect(Collectors.toList());
} catch (VppBaseCallException e) {
try {
// Execute with timeout
final CompletionStage<ShowVersionReply> showVersionFuture = getFutureJVpp().showVersion(new ShowVersion());
- final ShowVersionReply reply = TranslateUtils.getReply(showVersionFuture.toCompletableFuture(), id,
+ final ShowVersionReply reply = TranslateUtils.getReplyForRead(showVersionFuture.toCompletableFuture(), id,
DEFAULT_TIMEOUT_IN_SECONDS);
builder.setBranch(TranslateUtils.toString(reply.version));
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
}
private void whenCreateVhostUserIfThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException {
+ throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
final CompletionStage<CreateVhostUserIfReply> replyCS = mock(CompletionStage.class);
final CompletableFuture<CreateVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
final CreateVhostUserIfReply reply = new CreateVhostUserIfReply();
- when(replyFuture.get()).thenReturn(reply);
+ when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
when(api.createVhostUserIf(any(CreateVhostUserIf.class))).thenReturn(replyCS);
}
}
private void whenModifyVhostUserIfThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException {
+ throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
final CompletionStage<ModifyVhostUserIfReply> replyCS = mock(CompletionStage.class);
final CompletableFuture<ModifyVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
final ModifyVhostUserIfReply reply = new ModifyVhostUserIfReply();
- when(replyFuture.get()).thenReturn(reply);
+ when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
when(api.modifyVhostUserIf(any(ModifyVhostUserIf.class))).thenReturn(replyCS);
}
}
private void whenDeleteVhostUserIfThenSuccess()
- throws ExecutionException, InterruptedException, VppInvocationException {
+ throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
final CompletionStage<DeleteVhostUserIfReply> replyCS = mock(CompletionStage.class);
final CompletableFuture<DeleteVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
final DeleteVhostUserIfReply reply = new DeleteVhostUserIfReply();
- when(replyFuture.get()).thenReturn(reply);
+ when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
when(api.deleteVhostUserIf(any(DeleteVhostUserIf.class))).thenReturn(replyCS);
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
.augmentation(VppInterfaceAugmentation.class).child(Vxlan.class);
}
- private void whenVxlanAddDelTunnelThenSuccess() throws ExecutionException, InterruptedException, VppInvocationException {
+ private void whenVxlanAddDelTunnelThenSuccess()
+ throws ExecutionException, InterruptedException, VppInvocationException, TimeoutException {
final CompletionStage<VxlanAddDelTunnelReply> replyCS = mock(CompletionStage.class);
final CompletableFuture<VxlanAddDelTunnelReply> replyFuture = mock(CompletableFuture.class);
when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
final VxlanAddDelTunnelReply reply = new VxlanAddDelTunnelReply();
- when(replyFuture.get()).thenReturn(reply);
+ when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
when(api.vxlanAddDelTunnel(any(VxlanAddDelTunnel.class))).thenReturn(replyCS);
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
}
private void whenVxlanGpeAddDelTunnelThenSuccess()
- throws ExecutionException, InterruptedException, VppBaseCallException {
+ throws ExecutionException, InterruptedException, VppBaseCallException, TimeoutException {
final CompletionStage<VxlanGpeAddDelTunnelReply> replyCS = mock(CompletionStage.class);
final CompletableFuture<VxlanGpeAddDelTunnelReply> replyFuture = mock(CompletableFuture.class);
when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
final VxlanGpeAddDelTunnelReply reply = new VxlanGpeAddDelTunnelReply();
- when(replyFuture.get()).thenReturn(reply);
+ when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
when(api.vxlanGpeAddDelTunnel(any(VxlanGpeAddDelTunnel.class))).thenReturn(replyCS);
}
package io.fd.honeycomb.v3po.translate.v3po.test;
-import org.openvpp.jvpp.VppBaseCallException;
-import org.openvpp.jvpp.dto.SwInterfaceDetails;
-import org.openvpp.jvpp.dto.SwInterfaceDetailsReplyDump;
-import org.openvpp.jvpp.dto.SwInterfaceDump;
-import org.openvpp.jvpp.future.FutureJVpp;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.openvpp.jvpp.VppBaseCallException;
+import org.openvpp.jvpp.dto.SwInterfaceDetails;
+import org.openvpp.jvpp.dto.SwInterfaceDetailsReplyDump;
+import org.openvpp.jvpp.dto.SwInterfaceDump;
+import org.openvpp.jvpp.future.FutureJVpp;
public final class InterfaceTestUtils {
private InterfaceTestUtils() {
}
public static void whenSwInterfaceDumpThenReturn(final FutureJVpp api, final List<SwInterfaceDetails> interfaceList)
- throws ExecutionException, InterruptedException, VppBaseCallException {
+ throws ExecutionException, InterruptedException, VppBaseCallException, TimeoutException {
final CompletionStage<SwInterfaceDetailsReplyDump> replyCS = mock(CompletionStage.class);
final CompletableFuture<SwInterfaceDetailsReplyDump> replyFuture = mock(CompletableFuture.class);
when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
final SwInterfaceDetailsReplyDump reply = new SwInterfaceDetailsReplyDump();
reply.swInterfaceDetails = interfaceList;
- when(replyFuture.get()).thenReturn(reply);
+ when(replyFuture.get(anyLong(), eq(TimeUnit.SECONDS))).thenReturn(reply);
when(api.swInterfaceDump(any(SwInterfaceDump.class))).thenReturn(replyCS);
}
}
*/
@Override
public final void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataAfter,
- @Nonnull final WriteContext writeContext) throws WriteFailedException.CreateFailedException {
+ @Nonnull final WriteContext writeContext) throws WriteFailedException {
checkProperInterfaceType(writeContext, id);
writeInterface(id, dataAfter, writeContext);
}
protected abstract void writeInterface(final InstanceIdentifier<D> id, final D dataAfter,
final WriteContext writeContext)
- throws WriteFailedException.CreateFailedException;
+ throws WriteFailedException;
// Validation for update and delete is not necessary
public final class TranslateUtils {
public static final Splitter COLON_SPLITTER = Splitter.on(':');
+ public static final int DEFAULT_TIMEOUT_IN_SECONDS = 5;
private TranslateUtils() {
}
- public static <REP extends JVppReply<?>> REP getReply(Future<REP> future) throws VppBaseCallException {
+ public static <REP extends JVppReply<?>> REP getReplyForWrite(@Nonnull Future<REP> future,
+ @Nonnull final InstanceIdentifier<?> replyType)
+ throws VppBaseCallException, WriteTimeoutException {
+ return getReplyForWrite(future, replyType, DEFAULT_TIMEOUT_IN_SECONDS);
+ }
+
+ public static <REP extends JVppReply<?>> REP getReplyForWrite(@Nonnull Future<REP> future,
+ @Nonnull final InstanceIdentifier<?> replyType,
+ @Nonnegative final int timeoutInSeconds)
+ throws VppBaseCallException, WriteTimeoutException {
try {
- return future.get();
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- throw new IllegalStateException("Interrupted", e);
- } catch (ExecutionException e) {
- // Execution exception could generally contains any exception
- // when using exceptions instead of return codes just rethrow it for processing on corresponding place
- if (e instanceof ExecutionException && (e.getCause() instanceof VppBaseCallException)) {
- throw (VppBaseCallException) (e.getCause());
- }
- throw new IllegalStateException(e);
+ return getReply(future, timeoutInSeconds);
+ } catch (TimeoutException e) {
+ throw new WriteTimeoutException(replyType, e);
}
}
+ public static <REP extends JVppReply<?>> REP getReplyForRead(@Nonnull Future<REP> future,
+ @Nonnull final InstanceIdentifier<?> replyType)
+ throws VppBaseCallException, ReadTimeoutException {
+ return getReplyForRead(future, replyType, DEFAULT_TIMEOUT_IN_SECONDS);
+ }
+
+ public static <REP extends JVppReply<?>> REP getReplyForRead(@Nonnull Future<REP> future,
+ @Nonnull final InstanceIdentifier<?> replyType,
+ @Nonnegative final int timeoutInSeconds)
+ throws VppBaseCallException, ReadTimeoutException {
+ try {
+ return getReply(future, timeoutInSeconds);
+ } catch (TimeoutException e) {
+ throw new ReadTimeoutException(replyType, e);
+ }
+ }
+
+ public static <REP extends JVppReply<?>> REP getReply(@Nonnull Future<REP> future)
+ throws TimeoutException, VppBaseCallException {
+ return getReply(future, DEFAULT_TIMEOUT_IN_SECONDS);
+ }
+
public static <REP extends JVppReply<?>> REP getReply(@Nonnull Future<REP> future,
- @Nonnull final InstanceIdentifier<?> replyType,
@Nonnegative final int timeoutInSeconds)
- throws ReadTimeoutException, VppBaseCallException {
+ throws TimeoutException, VppBaseCallException {
try {
checkArgument(timeoutInSeconds > 0, "Timeout cannot be < 0");
return future.get(timeoutInSeconds, TimeUnit.SECONDS);
} catch (ExecutionException e) {
// Execution exception could generally contains any exception
// when using exceptions instead of return codes just rethrow it for processing on corresponding place
- if (e.getCause() instanceof VppBaseCallException) {
+ if (e instanceof ExecutionException && (e.getCause() instanceof VppBaseCallException)) {
throw (VppBaseCallException) (e.getCause());
}
throw new IllegalStateException(e);
- } catch (TimeoutException e) {
- throw new ReadTimeoutException(replyType, e);
}
}
/**
* Reverses bytes in the byte array
+ *
* @param bytes input array
* @return reversed array
*/
--- /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.util;
+
+import com.google.common.annotations.Beta;
+import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Thrown when write method invocation times out.
+ */
+@Beta
+public class WriteTimeoutException extends WriteFailedException {
+
+ public WriteTimeoutException(final InstanceIdentifier<?> id, final Throwable cause) {
+ super(id, cause);
+ }
+
+}
import static io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils.reverseBytes;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yangtools.yang.binding.DataContainer;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.dto.JVppReply;
public class TranslateUtilsTest {
+ private static class AnDataObject implements DataObject {
+ @Override
+ public Class<? extends DataContainer> getImplementedInterface() {
+ return null;
+ }
+ }
+
+ @Test
+ public void testGetReplyForWriteTimeout() throws Exception {
+ final Future<JVppReply<?>> future = mock(Future.class);
+ when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class);
+ final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class);
+ try {
+ TranslateUtils.getReplyForWrite(future, replyType);
+ } catch (WriteTimeoutException e) {
+ assertTrue(e.getCause() instanceof TimeoutException);
+ assertEquals(replyType, e.getFailedId());
+ return;
+ }
+ fail("WriteTimeoutException was expected");
+ }
+
+ @Test
+ public void testGetReplyForReadTimeout() throws Exception {
+ final Future<JVppReply<?>> future = mock(Future.class);
+ final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class);
+ when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class);
+ try {
+ TranslateUtils.getReplyForRead(future, replyType);
+ } catch (ReadTimeoutException e) {
+ assertTrue(e.getCause() instanceof TimeoutException);
+ assertEquals(replyType, e.getFailedId());
+ return;
+ }
+ fail("ReadTimeoutException was expected");
+ }
+
@Test
public void testIpv4NoZone() throws Exception {
final Ipv4AddressNoZone ipv4Addr = new Ipv4AddressNoZone("192.168.1.1");
public void testByteToBooleanFailed() {
TranslateUtils.byteToBoolean((byte) 123);
}
+
}
\ No newline at end of file
Code Review / hc2vpp.git / commitdiff