import java.math.BigInteger;
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowplugin.api.openflow.OFPContext;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceReplyProcessor;
*/
void shutdownConnection();
+ void initialSubmitTransaction();
+
/**
* Method add auxiliary connection contexts to this context representing single device connection.
* @param connectionContext new connection context
void setSwitchFeaturesMandatory(boolean switchFeaturesMandatory);
- void registerClusterSingletonServices(ClusterSingletonServiceProvider singletonServiceProvider);
-
}
package org.opendaylight.openflowplugin.api.openflow.device;
-import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.openflowplugin.api.openflow.OFPManager;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceConnectedHandler;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceDisconnectedHandler;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceLifecycleSupervisor;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceTerminationPhaseHandler;
import org.opendaylight.openflowplugin.api.openflow.translator.TranslatorLibrarian;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.OfpRole;
/**
* This interface is responsible for instantiating DeviceContext and
*/
void initialize();
- /**
- * Method has to activate (MASTER) or deactivate (SLAVE) TransactionChainManager.
- * TransactionChainManager represents possibility to write or delete Node subtree data
- * for actual Controller Cluster Node. We are able to have an active TxManager only if
- * newRole is {@link OfpRole#BECOMESLAVE}.
- * Parameters are used as marker to be sure it is change to SLAVE from MASTER or from
- * MASTER to SLAVE and the last parameter "cleanDataStore" is used for validation only.
- *
- * @param deviceInfo which device
- * @param role - NewRole expect to be {@link OfpRole#BECOMESLAVE} or {@link OfpRole#BECOMEMASTER}
- * @return RoleChangeTxChainManager future for activation/deactivation
- */
- ListenableFuture<Void> onClusterRoleChange(final DeviceInfo deviceInfo, final OfpRole role);
-
- /**
- * Register device synchronize listeners
- * @param deviceSynchronizeListener are notified if device is synchronized or not
- */
- void addDeviceSynchronizeListener(final DeviceSynchronizeListener deviceSynchronizeListener);
-
- /**
- * Notify all registered listeners about synchronized status
- * @param deviceInfo which device
- * @param deviceSynchronized true if device is synchronized
- */
- void notifyDeviceSynchronizeListeners(final DeviceInfo deviceInfo, final boolean deviceSynchronized);
-
- /**
- * Register device valid listeners
- * @param deviceValidListener are notified if device is valid or not
- */
- void addDeviceValidListener(final DeviceValidListener deviceValidListener);
-
- /**
- * Notify all registered listeners about valid status
- * @param deviceInfo which device
- * @param deviceValid true if device is valid
- */
- void notifyDeviceValidListeners(final DeviceInfo deviceInfo, final boolean deviceValid);
-
void setIsNotificationFlowRemovedOff(boolean value);
boolean getIsNotificationFlowRemovedOff();
/**
* Holder of device's structure
*/
-public interface DeviceState extends DeviceSynchronizeListener, DeviceValidListener {
-
- /**
- * @return true if this session is valid
- */
- boolean isValid();
+public interface DeviceState {
/**
* Return true if we have relevant meter information
*/
void setGroupAvailable(boolean available);
- /**
- * Method returns true if initial statistics data were collected and written to DS.
- *
- * @return
- */
- boolean deviceSynchronized();
-
/**
* Method returns true, if device capabilities provides flow statistics.
*
boolean isStatisticsPollingEnabled();
- void setStatisticsPollingEnabledProp(boolean statPollEnabled);
-
}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.openflowplugin.api.openflow.device;
-
-/**
- * API for device synchronized listeners
- */
-public interface DeviceSynchronizeListener {
-
- void deviceIsSynchronized(final DeviceInfo deviceInfo, final boolean isSynchronized);
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.openflowplugin.api.openflow.device;
-
-/**
- * API for device synchronized listeners
- */
-public interface DeviceValidListener {
-
- void deviceIsValid(final DeviceInfo deviceInfo, final boolean isValid);
-
-}
LOG.debug("Close connection called for node {}", deviceInfo);
final DeviceContext deviceContext = getDeviceContext(deviceInfo);
if (null != deviceContext) {
- deviceManager.notifyDeviceValidListeners(deviceInfo, false);
deviceContext.shutdownConnection();
}
}
LOG.info("Role change to {} in role context for node {} was successful.", newRole, deviceInfo.getNodeId().getValue());
- final String logText;
-
if (OfpRole.BECOMEMASTER.equals(newRole)) {
- logText = "Start";
fillDeviceFlowRegistry(deviceInfo, deviceContext.getDeviceFlowRegistry());
MdSalRegistrationUtils.registerServices(rpcContext, deviceContext, this.extensionConverterProvider, convertorExecutor);
notificationPublishService, convertorExecutor);
}
} else {
- logText = "Stopp";
statisticsManager.stopScheduling(deviceInfo);
// Clean device flow registry if we became slave
MdSalRegistrationUtils.unregisterServices(rpcContext);
}
- final ListenableFuture<Void> onClusterRoleChange = deviceManager.onClusterRoleChange(deviceInfo, newRole);
- Futures.addCallback(onClusterRoleChange, new FutureCallback<Void>() {
- @Override
- public void onSuccess(@Nullable final Void aVoid) {
- LOG.info("{}ing services for node {} was successful", logText, deviceInfo);
- if (newRole.equals(OfpRole.BECOMESLAVE)) {
- notifyServiceChangeListeners(deviceInfo, true);
- }
- }
-
- @Override
- public void onFailure(final Throwable throwable) {
- LOG.warn("{}ing services for node {} was NOT successful, closing connection", logText, deviceInfo.getNodeId().getValue());
- closeConnection(deviceInfo);
- }
- });
}
private void fillDeviceFlowRegistry(final DeviceInfo deviceInfo, final DeviceFlowRegistry deviceFlowRegistry) {
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.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue;
private final ConvertorExecutor convertorExecutor;
private volatile CONTEXT_STATE state;
- public DeviceContextImpl(@Nonnull final ConnectionContext primaryConnectionContext,
- @Nonnull final DeviceState deviceState,
- @Nonnull final DataBroker dataBroker,
- @Nonnull final LifecycleConductor conductor,
- @Nonnull final OutboundQueueProvider outboundQueueProvider,
- @Nonnull final TranslatorLibrary translatorLibrary,
- final DeviceManager manager,
- @Nonnull final DeviceInfo deviceInfo,
- final ConvertorExecutor convertorExecutor) {
+ public DeviceContextImpl(
+ @Nonnull final ConnectionContext primaryConnectionContext,
+ @Nonnull final DataBroker dataBroker,
+ @Nonnull final LifecycleConductor conductor,
+ @Nonnull final OutboundQueueProvider outboundQueueProvider,
+ @Nonnull final TranslatorLibrary translatorLibrary,
+ @Nonnull final DeviceManager manager,
+ final ConvertorExecutor convertorExecutor) {
this.primaryConnectionContext = Preconditions.checkNotNull(primaryConnectionContext);
- this.deviceState = Preconditions.checkNotNull(deviceState);
+ this.deviceInfo = primaryConnectionContext.getDeviceInfo();
+ this.deviceState = new DeviceStateImpl();
this.dataBroker = Preconditions.checkNotNull(dataBroker);
Preconditions.checkNotNull(conductor);
this.outboundQueueProvider = Preconditions.checkNotNull(outboundQueueProvider);
itemLifeCycleSourceRegistry = new ItemLifeCycleRegistryImpl();
flowLifeCycleKeeper = new ItemLifeCycleSourceImpl();
itemLifeCycleSourceRegistry.registerLifeCycleSource(flowLifeCycleKeeper);
- this.deviceInfo = deviceInfo;
this.state = CONTEXT_STATE.INITIALIZATION;
this.convertorExecutor = convertorExecutor;
}
* This method is called from {@link DeviceManagerImpl} only. So we could say "posthandshake process finish"
* and we are able to set a scheduler for an automatic transaction submitting by time (0,5sec).
*/
- void initialSubmitTransaction() {
+ @Override
+ public void initialSubmitTransaction() {
transactionChainManager.initialSubmitWriteTransaction();
}
this.switchFeaturesMandatory = switchFeaturesMandatory;
}
- @Override
- public void registerClusterSingletonServices(ClusterSingletonServiceProvider singletonServiceProvider) {
-
- }
-
@Override
public CONTEXT_STATE getState() {
return this.state;
package org.opendaylight.openflowplugin.impl.device;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import com.google.common.collect.Iterators;
-import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import io.netty.util.TimerTask;
import java.util.Collections;
-import java.util.HashSet;
import java.util.Iterator;
-import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceManager;
-import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
-import org.opendaylight.openflowplugin.api.openflow.device.DeviceSynchronizeListener;
-import org.opendaylight.openflowplugin.api.openflow.device.DeviceValidListener;
import org.opendaylight.openflowplugin.api.openflow.device.TranslatorLibrary;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceInitializationPhaseHandler;
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceTerminationPhaseHandler;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.LifecycleConductor;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.LifecycleService;
-import org.opendaylight.openflowplugin.api.openflow.statistics.StatisticsContext;
import org.opendaylight.openflowplugin.extension.api.ExtensionConverterProviderKeeper;
import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
import org.opendaylight.openflowplugin.impl.connection.OutboundQueueProviderImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.OfpRole;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final int barrierCountLimit;
private ExtensionConverterProvider extensionConverterProvider;
private ScheduledThreadPoolExecutor spyPool;
- private Set<DeviceSynchronizeListener> deviceSynchronizedListeners;
- private Set<DeviceValidListener> deviceValidListeners;
private final ClusterSingletonServiceProvider singletonServiceProvider;
private final LifecycleConductor conductor;
this.conductor = lifecycleConductor;
spyPool = new ScheduledThreadPoolExecutor(1);
- this.deviceSynchronizedListeners = new HashSet<>();
- this.deviceValidListeners = new HashSet<>();
this.singletonServiceProvider = singletonServiceProvider;
}
connectionAdapter.registerOutboundQueueHandler(outboundQueueProvider, barrierCountLimit, barrierIntervalNanos);
connectionContext.setOutboundQueueHandleRegistration(outboundQueueHandlerRegistration);
- final DeviceState deviceState = new DeviceStateImpl(deviceInfo);
- this.addDeviceSynchronizeListener(deviceState);
- this.addDeviceValidListener(deviceState);
-
final DeviceContext deviceContext = new DeviceContextImpl(connectionContext,
- deviceState,
dataBroker,
conductor,
outboundQueueProvider,
translatorLibrary,
this,
- connectionContext.getDeviceInfo(),
convertorExecutor);
final LifecycleService lifecycleService = new LifecycleServiceImpl();
final OpenflowProtocolListenerFullImpl messageListener = new OpenflowProtocolListenerFullImpl(
connectionAdapter, deviceContext);
- connectionAdapter.setMessageListener(messageListener);
- notifyDeviceValidListeners(deviceInfo, true);
-
- deviceInitPhaseHandler.onDeviceContextLevelUp(connectionContext.getDeviceInfo(), lifecycleServices.get(deviceInfo));
-
- notifyDeviceSynchronizeListeners(deviceInfo, true);
+ connectionAdapter.setMessageListener(messageListener);
+ deviceInitPhaseHandler.onDeviceContextLevelUp(connectionContext.getDeviceInfo(), lifecycleService);
return true;
}
for (final Iterator<DeviceContext> iterator = Iterators.consumingIterator(deviceContexts.values().iterator());
iterator.hasNext();) {
final DeviceContext deviceCtx = iterator.next();
- notifyDeviceValidListeners(deviceCtx.getDeviceInfo(), false);
deviceCtx.shutdownConnection();
deviceCtx.shuttingDownDataStoreTransactions();
}
/* Connection is not PrimaryConnection so try to remove from Auxiliary Connections */
deviceCtx.removeAuxiliaryConnectionContext(connectionContext);
} else {
- notifyDeviceValidListeners(deviceInfo, false);
/* Device is disconnected and so we need to close TxManager */
final ListenableFuture<Void> future = deviceCtx.shuttingDownDataStoreTransactions();
Futures.addCallback(future, new FutureCallback<Void>() {
return (T) deviceContexts.get(deviceInfo);
}
- @Override
- public ListenableFuture<Void> onClusterRoleChange(final DeviceInfo deviceInfo, final OfpRole role) {
- DeviceContext deviceContext = deviceContexts.get(deviceInfo);
- LOG.trace("onClusterRoleChange {} for node:", role, deviceInfo.getNodeId());
- if (OfpRole.BECOMEMASTER.equals(role)) {
- return onDeviceTakeClusterLeadership(deviceInfo);
- }
- return ((DeviceContextImpl)deviceContext).getTransactionChainManager().deactivateTransactionManager();
- }
-
- @Override
- public void addDeviceSynchronizeListener(final DeviceSynchronizeListener deviceSynchronizeListener) {
- this.deviceSynchronizedListeners.add(deviceSynchronizeListener);
- }
-
- @Override
- public void notifyDeviceSynchronizeListeners(final DeviceInfo deviceInfo, final boolean deviceSynchronized) {
- for (DeviceSynchronizeListener listener : deviceSynchronizedListeners) {
- listener.deviceIsSynchronized(deviceInfo, deviceSynchronized);
- }
- }
-
- @Override
- public void addDeviceValidListener(final DeviceValidListener deviceValidListener) {
- this.deviceValidListeners.add(deviceValidListener);
- }
-
- @Override
- public void notifyDeviceValidListeners(final DeviceInfo deviceInfo, final boolean deviceValid) {
- for (DeviceValidListener listener : deviceValidListeners) {
- listener.deviceIsValid(deviceInfo, deviceValid);
- }
- }
-
@Override
public void setIsNotificationFlowRemovedOff(boolean isNotificationFlowRemovedOff) {
this.isNotificationFlowRemovedOff = isNotificationFlowRemovedOff;
return this.isNotificationFlowRemovedOff;
}
- private ListenableFuture<Void> onDeviceTakeClusterLeadership(final DeviceInfo deviceInfo) {
- LOG.trace("onDeviceTakeClusterLeadership for node: {}", deviceInfo.getNodeId());
- /* validation */
- StatisticsContext statisticsContext = conductor.getStatisticsContext(deviceInfo);
- if (statisticsContext == null) {
- final String errMsg = String.format("DeviceCtx %s is up but we are missing StatisticsContext", deviceInfo.getDatapathId());
- LOG.warn(errMsg);
- return Futures.immediateFailedFuture(new IllegalStateException(errMsg));
- }
- DeviceContext deviceContext = deviceContexts.get(deviceInfo);
- /* Prepare init info collecting */
- notifyDeviceSynchronizeListeners(deviceInfo, false);
- ((DeviceContextImpl)deviceContext).getTransactionChainManager().activateTransactionManager();
- ((DeviceContextImpl)deviceContext).getTransactionChainManager().initialSubmitWriteTransaction();
- /* Init Collecting NodeInfo */
- final ListenableFuture<Void> initCollectingDeviceInfo = DeviceInitializationUtils.initializeNodeInformation(
- deviceContext, switchFeaturesMandatory, convertorExecutor);
- /* Init Collecting StatInfo */
- final ListenableFuture<Boolean> statPollFuture = Futures.transform(initCollectingDeviceInfo,
- new AsyncFunction<Void, Boolean>() {
-
- @Override
- public ListenableFuture<Boolean> apply(@Nonnull final Void input) throws Exception {
- statisticsContext.statListForCollectingInitialization();
- return statisticsContext.initialGatherDynamicData();
- }
- });
-
- return Futures.transform(statPollFuture, getInitialDeviceInformation(deviceContext));
- }
-
- private Function<Boolean, Void> getInitialDeviceInformation(final DeviceContext deviceContext) {
- return input -> {
- if (ConnectionContext.CONNECTION_STATE.RIP.equals(
- conductor.gainConnectionStateSafely(deviceContext.getDeviceInfo())
- )) {
- final String errMsg =
- String.format("We lost connection for Device %s, context has to be closed.",
- deviceContext.getDeviceInfo().getNodeId());
- LOG.warn(errMsg);
- throw new IllegalStateException(errMsg);
- }
-
- if (input == null || !input) {
- final String errMsg =
- String.format("Get Initial Device %s information fails",
- deviceContext.getDeviceInfo().getNodeId());
- LOG.warn(errMsg);
- throw new IllegalStateException(errMsg);
- }
- LOG.debug("Get Initial Device {} information is successful",
- deviceContext.getDeviceInfo().getNodeId());
- notifyDeviceSynchronizeListeners(deviceContext.getDeviceInfo(), true);
- deviceContext.getDeviceState().setStatisticsPollingEnabledProp(true);
- return null;
- };
- }
-
}
package org.opendaylight.openflowplugin.impl.device;
-import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply;
*/
class DeviceStateImpl implements DeviceState {
- private final DeviceInfo deviceInfo;
- private boolean valid;
private boolean meterIsAvailable;
private boolean groupIsAvailable;
- private boolean deviceSynchronized;
private boolean flowStatisticsAvailable;
private boolean tableStatisticsAvailable;
private boolean portStatisticsAvailable;
private boolean statPollEnabled;
private boolean queueStatisticsAvailable;
- public DeviceStateImpl(final DeviceInfo deviceInfo) {
- this.deviceInfo = deviceInfo;
+ public DeviceStateImpl() {
statPollEnabled = false;
- deviceSynchronized = false;
- }
-
- @Override
- public boolean isValid() {
- return valid;
}
@Override
groupIsAvailable = available;
}
- @Override
- public boolean deviceSynchronized() {
- return deviceSynchronized;
- }
-
@Override
public boolean isFlowStatisticsAvailable() {
return flowStatisticsAvailable;
return statPollEnabled;
}
- @Override
- public void setStatisticsPollingEnabledProp(final boolean statPollEnabled) {
- this.statPollEnabled = statPollEnabled;
- }
-
- @Override
- public void deviceIsSynchronized(final DeviceInfo deviceInfo, final boolean isSynchronized) {
- if (this.deviceInfo.equals(deviceInfo)) {
- this.deviceSynchronized = isSynchronized;
- }
- }
-
- @Override
- public void deviceIsValid(final DeviceInfo deviceInfo, final boolean isValid) {
- if (this.deviceInfo.equals(deviceInfo)) {
- this.valid = isValid;
- }
- }
}
LOG.info("Starting statistics context cluster services for node {}", getIdentifier());
this.statContext.startupClusterServices();
+ LOG.info("Statistics initial gathering OK, submitting data for node {}", getIdentifier());
+ this.deviceContext.initialSubmitTransaction();
+
LOG.info("Starting rpc context cluster services for node {}", getIdentifier());
this.rpcContext.startupClusterServices();
LOG.debug("Disabling statistics scheduling for device: {}", deviceInfo.getNodeId());
return;
}
-
- if (!deviceState.isValid()) {
- LOG.debug("Session is not valid for device: {}", deviceInfo.getNodeId());
- return;
- }
if (!deviceState.isStatisticsPollingEnabled()) {
LOG.debug("Statistics polling is currently disabled for device: {}", deviceInfo.getNodeId());
when(deviceContext.getDeviceState()).thenReturn(deviceState);
when(deviceContext.getDeviceFlowRegistry()).thenReturn(new DeviceFlowRegistryImpl(dataBroker, nodeInstanceIdentifier));
when(deviceManager.gainContext(deviceInfo)).thenReturn(deviceContext);
- when(deviceManager.onClusterRoleChange(deviceInfo, OfpRole.BECOMEMASTER)).thenReturn(listenableFuture);
lifecycleConductor.roleChangeOnDevice(deviceInfo,OfpRole.BECOMEMASTER);
verify(statisticsManager).startScheduling(Mockito.<DeviceInfo>any());
}
when(deviceContext.getDeviceState()).thenReturn(deviceState);
when(deviceContext.getDeviceFlowRegistry()).thenReturn(new DeviceFlowRegistryImpl(dataBroker, nodeInstanceIdentifier));
when(deviceManager.gainContext(deviceInfo)).thenReturn(deviceContext);
- when(deviceManager.onClusterRoleChange(deviceInfo, OfpRole.BECOMESLAVE)).thenReturn(listenableFuture);
lifecycleConductor.roleChangeOnDevice(deviceInfo,OfpRole.BECOMESLAVE);
verify(statisticsManager).stopScheduling(Mockito.<DeviceInfo>any());
deviceContext = new DeviceContextImpl(
connectionContext,
- deviceState,
dataBroker,
lifecycleConductor,
outboundQueueProvider,
translatorLibrary,
deviceManager,
- deviceInfo,
convertorExecutor);
deviceContextSpy = Mockito.spy(deviceContext);
@Test(expected = NullPointerException.class)
public void testDeviceContextImplConstructorNullDataBroker() throws Exception {
- new DeviceContextImpl(connectionContext, deviceState, null, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, deviceInfo, convertorExecutor).close();
- }
+ new DeviceContextImpl(connectionContext, null, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, convertorExecutor).close();
- @Test(expected = NullPointerException.class)
- public void testDeviceContextImplConstructorNullDeviceState() throws Exception {
- new DeviceContextImpl(connectionContext, null, dataBroker, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, deviceInfo, convertorExecutor).close();
}
@Test(expected = NullPointerException.class)
public void testDeviceContextImplConstructorNullTimer() throws Exception {
- new DeviceContextImpl(null, deviceState, dataBroker, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, deviceInfo, convertorExecutor).close();
- }
- @Test
- public void testGetDeviceState() {
- final DeviceState deviceSt = deviceContext.getDeviceState();
- assertNotNull(deviceSt);
- assertEquals(deviceState, deviceSt);
+ new DeviceContextImpl(null, dataBroker, lifecycleConductor, outboundQueueProvider, translatorLibrary, deviceManager, convertorExecutor).close();
}
@Test
final ConnectionContext mockedAuxiliaryConnectionContext = prepareConnectionContext();
deviceContext.addAuxiliaryConnectionContext(mockedAuxiliaryConnectionContext);
- final DeviceTerminationPhaseHandler mockedDeviceContextClosedHandler = mock(DeviceTerminationPhaseHandler.class);
- when(deviceState.isValid()).thenReturn(true);
deviceContext.shutdownConnection();
verify(connectionContext).closeConnection(true);
}
@Before
public void initialization() {
- deviceState = new DeviceStateImpl(deviceInfo);
- }
-
- @Test
- public void testIsValid_initialValue(){
- Assert.assertFalse(deviceState.isValid());
- }
-
- @Test
- public void testDeviceSynchronized_initialValue(){
- Assert.assertFalse(deviceState.deviceSynchronized());
+ deviceState = new DeviceStateImpl();
}
@Test
when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedPrimaryConnection);
when(mockedDeviceInfo.getNodeInstanceIdentifier()).thenReturn(NODE_PATH);
- when(mockedDeviceState.deviceSynchronized()).thenReturn(true);
when(mockedDeviceInfo.getNodeId()).thenReturn(mockedNodeId);
when(mockedDeviceInfo.getDatapathId()).thenReturn(BigInteger.TEN);
when(mockedDeviceInfo.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
@Override
protected void setup() {
salExperimenterMessageService = new SalExperimenterMessageServiceImpl(mockedRequestContextStack, mockedDeviceContext, extensionConverterProvider);
- Mockito.when(mockedDeviceContext.getExtensionConverterProvider()).thenReturn(extensionConverterProvider);
Mockito.when(extensionConverterProvider.getMessageConverter(Matchers.<TypeVersionKey>any()))
.thenReturn(extensionConverter);
Mockito.when(extensionConverter.getExperimenterId()).thenReturn(new ExperimenterId(43L));
@Test
public void testDeleteAllKnownFlows() throws Exception {
final short tableId = 0;
- when(deviceState.deviceSynchronized()).thenReturn(true);
final InstanceIdentifier<FlowCapableNode> nodePath = deviceInfo.getNodeInstanceIdentifier().augmentation(FlowCapableNode.class);
final TableBuilder tableDataBld = new TableBuilder();
tableDataBld.setId(tableId);
statisticsManager.pollStatistics(mockedDeviceContext.getDeviceState(), statisticsContext, mockTimerCounter, mockedDeviceInfo);
verify(mockedDeviceContext).getDeviceState();
- when(mockedDeviceContext.getDeviceState().isValid()).thenReturn(true);
statisticsManager.pollStatistics(mockedDeviceContext.getDeviceState(), statisticsContext, mockTimerCounter, mockedDeviceInfo);
when(mockedDeviceContext.getDeviceState().isStatisticsPollingEnabled()).thenReturn(true);
Code Review / openflowplugin.git / commitdiff