import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.Objects;
import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainClosedException;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-/**
- *
- */
public class DeviceContextImpl implements DeviceContext, ExtensionConverterProviderKeeper{
private static final Logger LOG = LoggerFactory.getLogger(DeviceContextImpl.class);
@Override
public void initialSubmitTransaction() {
- transactionChainManager.initialSubmitWriteTransaction();
+ if (initialized) {
+ transactionChainManager.initialSubmitWriteTransaction();
+ }
}
@Override
public <T extends DataObject> void writeToTransaction(final LogicalDatastoreType store,
final InstanceIdentifier<T> path,
final T data){
- if (Objects.nonNull(transactionChainManager)) {
+ if (initialized) {
transactionChainManager.writeToTransaction(store, path, data, false);
}
}
public <T extends DataObject> void writeToTransactionWithParentsSlow(final LogicalDatastoreType store,
final InstanceIdentifier<T> path,
final T data){
- if (Objects.nonNull(transactionChainManager)) {
+ if (initialized) {
transactionChainManager.writeToTransaction(store, path, data, true);
}
}
@Override
- public <T extends DataObject> void addDeleteToTxChain(final LogicalDatastoreType store, final InstanceIdentifier<T> path) throws TransactionChainClosedException {
- if (Objects.nonNull(transactionChainManager)) {
+ public <T extends DataObject> void addDeleteToTxChain(final LogicalDatastoreType store, final InstanceIdentifier<T> path) {
+ if (initialized) {
transactionChainManager.addDeleteOperationTotTxChain(store, path);
}
}
@Override
public boolean submitTransaction() {
- return Objects.nonNull(transactionChainManager) && transactionChainManager.submitWriteTransaction();
+ return initialized && transactionChainManager.submitWriteTransaction();
}
@Override
}
submitTransaction();
} catch (final Exception e) {
- LOG.warn("Error processing port status message: ", e);
+ LOG.warn("Error processing port status message for port {} on device {} : {}", portStatus.getPortNo(),
+ getDeviceInfo().getNodeId().toString(), e);
}
}
LOG.debug("ConnectionCtx for Node {} is in RIP state.", getDeviceInfo().getLOGValue());
return;
}
- /* Terminate Auxiliary Connection */
+
+ // Terminate Auxiliary Connection
for (final ConnectionContext connectionContext : auxiliaryConnectionContexts.values()) {
LOG.debug("Closing auxiliary connection {}", connectionContext.getNodeId());
connectionContext.closeConnection(false);
}
- /* Terminate Primary Connection */
+
+ // Terminate Primary Connection
getPrimaryConnectionContext().closeConnection(true);
- /* Close all Group Registry */
- deviceGroupRegistry.close();
- deviceFlowRegistry.close();
- deviceMeterRegistry.close();
+
+ // Close all datastore registries
+ if (initialized) {
+ deviceGroupRegistry.close();
+ deviceFlowRegistry.close();
+ deviceMeterRegistry.close();
+ }
}
@Override
public ListenableFuture<Void> shuttingDownDataStoreTransactions() {
- ListenableFuture<Void> future = Futures.immediateFuture(null);
- if (Objects.nonNull(this.transactionChainManager)) {
- future = this.transactionChainManager.shuttingDown();
- }
- return future;
+ return initialized
+ ? this.transactionChainManager.shuttingDown()
+ : Futures.immediateFuture(null);
}
@VisibleForTesting
@Override
public ListenableFuture<Void> stopClusterServices(boolean deviceDisconnected) {
- ListenableFuture<Void> future = Futures.immediateFuture(null);
- if (Objects.nonNull(this.transactionChainManager)) {
- future = this.transactionChainManager.deactivateTransactionManager();
- }
- return future;
+ return initialized
+ ? this.transactionChainManager.deactivateTransactionManager()
+ : Futures.immediateFuture(null);
}
@Override
@Override
public void putLifecycleServiceIntoTxChainManager(final LifecycleService lifecycleService){
- if (Objects.nonNull(this.transactionChainManager)) {
+ if (initialized) {
this.transactionChainManager.setLifecycleService(lifecycleService);
}
}
LOG.info("Starting device context cluster services for node {}", deviceInfo.getLOGValue());
- lazyTransactionManagerInitialiaztion();
+ lazyTransactionManagerInitialization();
this.transactionChainManager.activateTransactionManager();
}
@VisibleForTesting
- void lazyTransactionManagerInitialiaztion() {
+ void lazyTransactionManagerInitialization() {
if (!this.initialized) {
if (LOG.isDebugEnabled()) {
LOG.debug("Transaction chain manager for node {} created", deviceInfo.getLOGValue());