package org.opendaylight.openflowplugin.api.openflow.device;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.openflowplugin.api.openflow.OFPManager;
*/
void initialize();
- CheckedFuture<Void, TransactionCommitFailedException> removeDeviceFromOperationalDS(
+ ListenableFuture<Void> removeDeviceFromOperationalDS(
@Nonnull KeyedInstanceIdentifier<Node, NodeKey> ii);
DeviceContext createContext(@Nonnull ConnectionContext connectionContext);
*/
package org.opendaylight.openflowplugin.impl.device;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import io.netty.util.HashedWheelTimer;
import io.netty.util.internal.ConcurrentSet;
import java.util.Optional;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueHandlerRegistration;
import org.opendaylight.openflowplugin.api.openflow.OFPContext;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> removeDeviceFromOperationalDS(final KeyedInstanceIdentifier<Node, NodeKey> ii) {
+ public ListenableFuture<Void> removeDeviceFromOperationalDS(
+ @Nonnull final KeyedInstanceIdentifier<Node, NodeKey> ii) {
+
final WriteTransaction delWtx = dataBroker.newWriteOnlyTransaction();
delWtx.delete(LogicalDatastoreType.OPERATIONAL, ii);
- final CheckedFuture<Void, TransactionCommitFailedException> delFuture = delWtx.submit();
-
- Futures.addCallback(delFuture, new FutureCallback<Void>() {
- @Override
- public void onSuccess(final Void result) {
- if (LOG.isDebugEnabled()) {
- LOG.debug("Delete Node {} was successful", ii);
- }
- }
-
- @Override
- public void onFailure(@Nonnull final Throwable t) {
- LOG.warn("Delete node {} failed with exception {}", ii, t);
- }
- });
+ return delWtx.submit();
- return delFuture;
}
public DeviceContext createContext(@Nonnull final ConnectionContext connectionContext) {
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.CancellationException;
Preconditions.checkState(TransactionChainManagerStatus.WORKING == transactionChainManagerStatus,
"we have here Uncompleted Transaction for node {} and we are not MASTER",
this.nodeId);
- final CheckedFuture<Void, TransactionCommitFailedException> submitFuture = wTx.submit();
+ final ListenableFuture<Void> submitFuture = wTx.submit();
lastSubmittedFuture = submitFuture;
wTx = null;
}
}
}
- });
+ }, MoreExecutors.directExecutor());
}
return true;
}
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
deviceManager.sendNodeRemovedNotification(nodeInstanceIdentifier);
- LOG.info("Removing device {} from operational DS", nodeId);
+ LOG.info("Try to remove device {} from operational DS", nodeId);
deviceManager
.removeDeviceFromOperationalDS(nodeInstanceIdentifier)
- .checkedGet(REMOVE_DEVICE_FROM_DS_TIMEOUT, TimeUnit.MILLISECONDS);
- } catch (TimeoutException | TransactionCommitFailedException | NullPointerException e) {
- LOG.info("Not able to remove device {} from operational DS. Probably removed by another cluster node.",
- nodeId);
+ .get(REMOVE_DEVICE_FROM_DS_TIMEOUT, TimeUnit.MILLISECONDS);
+ LOG.info("Removing device from operational DS {} was successful", nodeId);
+ } catch (TimeoutException | ExecutionException | NullPointerException | InterruptedException e) {
+ LOG.warn("Not able to remove device {} from operational DS. ",nodeId, e);
}
}
}
import static org.mockito.Mockito.when;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import io.netty.util.HashedWheelTimer;
import java.lang.reflect.Field;
import java.math.BigInteger;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
+import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.NonZeroUint32Type;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.OpenflowProviderConfigBuilder;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcError;
@RunWith(MockitoJUnitRunner.class)
public class DeviceManagerImplTest {
@Test
public void removeDeviceFromOperationalDS() throws Exception {
- final CheckedFuture<Void, TransactionCommitFailedException> future = deviceManager
+ final ListenableFuture<Void> future = deviceManager
.removeDeviceFromOperationalDS(DUMMY_IDENTIFIER);
future.get();
verify(writeTransaction).delete(LogicalDatastoreType.OPERATIONAL, DUMMY_IDENTIFIER);
}
+ @Test(expected = ExecutionException.class)
+ public void removeDeviceFromOperationalDSException() throws Exception {
+ final CheckedFuture<Void, TransactionCommitFailedException> failedFuture =
+ Futures.immediateFailedCheckedFuture(
+ new TransactionCommitFailedException("Test failed transaction", null, null));
+ Mockito.when(writeTransaction.submit()).thenReturn(failedFuture);
+ final ListenableFuture<Void> future = deviceManager
+ .removeDeviceFromOperationalDS(DUMMY_IDENTIFIER);
+ future.get();
+ assertTrue(future.isDone());
+ verify(writeTransaction).delete(LogicalDatastoreType.OPERATIONAL, DUMMY_IDENTIFIER);
+ }
+
@Test
public void sendNodeAddedNotification() throws Exception {
deviceManager.sendNodeAddedNotification(DUMMY_IDENTIFIER);
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipChange;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipListenerRegistration;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.impl.mastership.MastershipChangeServiceManagerImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.rf.state.rev170713.ResultState;
+import org.opendaylight.yangtools.yang.common.RpcError;
@RunWith(MockitoJUnitRunner.class)
public class ContextChainHolderImplTest {
contextChainHolder.ownershipChanged(ownershipChange);
Mockito.verify(deviceManager).removeDeviceFromOperationalDS(Mockito.any());
}
- @Test
+ @Test
public void ownershipChangedButHasOwner() throws Exception {
registration.close();
contextChainHolder.createContextChain(connectionContext);