XidSequencer,
OFPContext{
- void setStatisticsRpcEnabled(boolean isStatisticsRpcEnabled);
-
/**
* distinguished device context states
*/
* This interface is responsible for instantiating DeviceContext and
* registering transaction chain for each DeviceContext. Each device
* has its own device context managed by this manager.
- * Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
public interface DeviceManager extends DeviceConnectedHandler, DeviceDisconnectedHandler, DeviceLifecycleSupervisor,
DeviceInitializationPhaseHandler, DeviceTerminationPhaseHandler, TranslatorLibrarian, AutoCloseable, OFPManager {
- /**
- * Sets notification publish service
- *
- * @param notificationPublishService
- */
- void setNotificationPublishService(NotificationPublishService notificationPublishService);
/**
* invoked after all services injected
*/
DeviceContext getDeviceContextFromNodeId(DeviceInfo deviceInfo);
- void setStatisticsRpcEnabled(boolean isStatisticsRpcEnabled);
}
import io.netty.util.Timeout;
import io.netty.util.TimerTask;
+import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.OFPManager;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
*/
void addOneTimeListenerWhenServicesChangesDone(final ServiceChangeListener manager, final DeviceInfo deviceInfo);
- /**
- * Returns device of version
- * @param deviceInfo node identification
- * @return null if device context doesn't exists
- */
- Short gainVersionSafely(final DeviceInfo deviceInfo);
-
/**
* Set new timeout for {@link io.netty.util.HashedWheelTimer}
* @param task timer task
* @return
*/
Long reserveXidForDeviceMessage(final DeviceInfo deviceInfo);
+
+ NotificationPublishService getNotificationPublishService();
+
+ void setNotificationPublishService(NotificationPublishService notificationPublishService);
}
@Override
void close();
+
+ void setStatisticsRpcEnabled(boolean isStatisticsRpcEnabled);
+
+ boolean isStatisticsRpcEnabled();
}
*/
public interface RpcManager extends DeviceLifecycleSupervisor, DeviceInitializationPhaseHandler, AutoCloseable, DeviceTerminationPhaseHandler, OFPManager {
+ void setStatisticsRpcEnabled(boolean statisticsRpcEnabled);
}
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
+import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.openflowplugin.api.openflow.OFPManager;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.LifecycleConductor;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.RoleChangeListener;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.ServiceChangeListener;
+import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcManager;
import org.opendaylight.openflowplugin.api.openflow.statistics.StatisticsManager;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageIntelligenceAgency;
private RpcManager rpcManager;
private final MessageIntelligenceAgency messageIntelligenceAgency;
private ConcurrentHashMap<DeviceInfo, ServiceChangeListener> serviceChangeListeners = new ConcurrentHashMap<>();
+ private NotificationPublishService notificationPublishService;
LifecycleConductorImpl(final MessageIntelligenceAgency messageIntelligenceAgency) {
Preconditions.checkNotNull(messageIntelligenceAgency);
return;
}
- LOG.info("Role change to {} in role context for node {} was successful, starting/stopping services.", newRole, deviceInfo);
+ LOG.info("Role change to {} in role context for node {} was successful.", newRole, deviceInfo);
final String logText;
rpcManager.gainContext(deviceInfo),
deviceContext,
OfpRole.BECOMEMASTER);
+ if (((RpcContext)rpcManager.gainContext(deviceInfo)).isStatisticsRpcEnabled()) {
+ MdSalRegistrationUtils.registerStatCompatibilityServices(
+ rpcManager.gainContext(deviceInfo),
+ deviceManager.gainContext(deviceInfo),
+ notificationPublishService,
+ new AtomicLong());
+ }
} else {
logText = "Stopp";
statisticsManager.stopScheduling(deviceInfo);
@Override
public DeviceContext getDeviceContext(DeviceInfo deviceInfo){
- return deviceManager.getDeviceContextFromNodeId(deviceInfo);
- }
-
- @Override
- public Short gainVersionSafely(final DeviceInfo deviceInfo) {
- return (null != getDeviceContext(deviceInfo)) ? getDeviceContext(deviceInfo).getPrimaryConnectionContext().getFeatures().getVersion() : null;
+ return deviceManager.gainContext(deviceInfo);
}
public Timeout newTimeout(@Nonnull TimerTask task, long delay, @Nonnull TimeUnit unit) {
return this.serviceChangeListeners.isEmpty();
}
+ @Override
+ public NotificationPublishService getNotificationPublishService() {
+ return notificationPublishService;
+ }
+
+ @Override
+ public void setNotificationPublishService(NotificationPublishService notificationPublishService) {
+ this.notificationPublishService = notificationPublishService;
+ }
}
((ExtensionConverterProviderKeeper) deviceManager).setExtensionConverterProvider(extensionConverterManager);
conductor.setSafelyManager(deviceManager);
+ conductor.setNotificationPublishService(notificationPublishService);
roleManager = new RoleManagerImpl(entityOwnershipService, dataBroker, conductor);
statisticsManager = new StatisticsManagerImpl(rpcProviderRegistry, isStatisticsPollingOff, conductor);
statisticsManager.setDeviceTerminationPhaseHandler(roleManager);
roleManager.setDeviceTerminationPhaseHandler(deviceManager);
- deviceManager.setStatisticsRpcEnabled(isStatisticsRpcEnabled);
- deviceManager.setNotificationPublishService(notificationPublishService);
+ rpcManager.setStatisticsRpcEnabled(isStatisticsRpcEnabled);
TranslatorLibraryUtil.setBasicTranslatorLibrary(deviceManager);
deviceManager.initialize();
private final DeviceInfo deviceInfo;
private volatile DEVICE_CONTEXT_STATE deviceCtxState;
- private boolean isStatisticsRpcEnabled;
-
@VisibleForTesting
DeviceContextImpl(@Nonnull final ConnectionContext primaryConnectionContext,
return Futures.immediateFailedFuture(new IllegalStateException(errMsg));
}
- if (isStatisticsRpcEnabled) {
- MdSalRegistrationUtils.registerStatCompatibilityServices(getRpcContext(), this,
- notificationPublishService, new AtomicLong());
- }
-
/* Prepare init info collecting */
getDeviceState().setDeviceSynchronized(false);
transactionChainManager.activateTransactionManager();
deviceMeterRegistry.close();
}
- @Override
- public void setStatisticsRpcEnabled(boolean isStatisticsRpcEnabled) {
- this.isStatisticsRpcEnabled = isStatisticsRpcEnabled;
- }
-
@Override
public DEVICE_CONTEXT_STATE getDeviceContextState() {
return deviceCtxState;
private TranslatorLibrary translatorLibrary;
private DeviceInitializationPhaseHandler deviceInitPhaseHandler;
private DeviceTerminationPhaseHandler deviceTerminPhaseHandler;
- private NotificationPublishService notificationPublishService;
private final ConcurrentMap<DeviceInfo, DeviceContext> deviceContexts = new ConcurrentHashMap<>();
private ScheduledThreadPoolExecutor spyPool;
private final LifecycleConductor conductor;
- private boolean isStatisticsRpcEnabled;
public DeviceManagerImpl(@Nonnull final DataBroker dataBroker,
final long globalNotificationQuota, final boolean switchFeaturesMandatory,
Verify.verify(deviceContexts.putIfAbsent(deviceInfo, deviceContext) == null, "DeviceCtx still not closed.");
((ExtensionConverterProviderKeeper) deviceContext).setExtensionConverterProvider(extensionConverterProvider);
- deviceContext.setStatisticsRpcEnabled(isStatisticsRpcEnabled);
- deviceContext.setNotificationPublishService(notificationPublishService);
+ deviceContext.setNotificationPublishService(conductor.getNotificationPublishService());
updatePacketInRateLimiters();
this.translatorLibrary = translatorLibrary;
}
- @Override
- public void setNotificationPublishService(final NotificationPublishService notificationService) {
- notificationPublishService = notificationService;
- }
-
@Override
public void close() {
for (final Iterator<DeviceContext> iterator = Iterators.consumingIterator(deviceContexts.values().iterator());
return deviceContexts.get(deviceInfo);
}
- @Override
- public void setStatisticsRpcEnabled(boolean isStatisticsRpcEnabled) {
- this.isStatisticsRpcEnabled = isStatisticsRpcEnabled;
- }
-
@Override
public void setExtensionConverterProvider(final ExtensionConverterProvider extensionConverterProvider) {
this.extensionConverterProvider = extensionConverterProvider;
private final MessageSpy messageSpy;
private final Semaphore tracker;
private final XidSequencer xidSequencer;
+ private boolean isStatisticsRpcEnabled;
// TODO: add private Sal salBroker
private final ConcurrentMap<Class<?>, RoutedRpcRegistration<?>> rpcRegistrations = new ConcurrentHashMap<>();
return this.rpcRegistrations.isEmpty();
}
+ @Override
+ public void setStatisticsRpcEnabled(boolean isStatisticsRpcEnabled) {
+ this.isStatisticsRpcEnabled = isStatisticsRpcEnabled;
+ }
+ @Override
+ public boolean isStatisticsRpcEnabled() {
+ return isStatisticsRpcEnabled;
+ }
}
private DeviceTerminationPhaseHandler deviceTerminPhaseHandler;
private final int maxRequestsQuota;
private final ConcurrentMap<DeviceInfo, RpcContext> contexts = new ConcurrentHashMap<>();
+ private boolean isStatisticsRpcEnabled;
private final LifecycleConductor conductor;
Verify.verify(contexts.putIfAbsent(deviceInfo, rpcContext) == null, "RpcCtx still not closed for node {}", deviceInfo.getNodeId());
+ rpcContext.setStatisticsRpcEnabled(isStatisticsRpcEnabled);
+
// finish device initialization cycle back to DeviceManager
deviceInitPhaseHandler.onDeviceContextLevelUp(deviceInfo);
}
public <T extends OFPContext> T gainContext(DeviceInfo deviceInfo) {
return (T) contexts.get(deviceInfo);
}
+
+
+ @Override
+ public void setStatisticsRpcEnabled(boolean statisticsRpcEnabled) {
+ isStatisticsRpcEnabled = statisticsRpcEnabled;
+ }
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcManager;
import org.opendaylight.openflowplugin.api.openflow.statistics.StatisticsManager;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageIntelligenceAgency;
+import org.opendaylight.openflowplugin.impl.util.MdSalRegistrationUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.OfpRole;
@Before
public void setUp() {
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(deviceContext);
- when(deviceContext.getPrimaryConnectionContext()).thenReturn(connectionContext);
lifecycleConductor = new LifecycleConductorImpl(messageIntelligenceAgency);
lifecycleConductor.setSafelyManager(deviceManager);
lifecycleConductor.setSafelyManager(statisticsManager);
lifecycleConductor.setSafelyManager(rpcManager);
- when(connectionContext.getFeatures()).thenReturn(featuresReply);
+ when(deviceManager.gainContext(Mockito.<DeviceInfo>any())).thenReturn(deviceContext);
+ when(deviceContext.getPrimaryConnectionContext()).thenReturn(connectionContext);
+ when(deviceContext.getDeviceInfo()).thenReturn(deviceInfo);
+ when(rpcManager.gainContext(Mockito.<DeviceInfo>any())).thenReturn(rpcContext);
when(deviceInfo.getNodeId()).thenReturn(nodeId);
when(deviceInfo.getDatapathId()).thenReturn(BigInteger.TEN);
when(deviceContext.getDeviceInfo()).thenReturn(deviceInfo);
*/
@Test
public void roleChangeOnDeviceTest1() {
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(null);
+ when(deviceManager.gainContext(deviceInfo)).thenReturn(null);
lifecycleConductor.roleChangeOnDevice(deviceInfo,true,ofpRole,false);
verify(deviceContext,times(0)).shutdownConnection();
lifecycleConductor.roleChangeOnDevice(deviceInfo,false,ofpRole,false);
*/
@Test
public void roleChangeOnDeviceTest2() {
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(deviceContext);
+ when(deviceManager.gainContext(deviceInfo)).thenReturn(deviceContext);
lifecycleConductor.roleChangeOnDevice(deviceInfo,false,ofpRole,false);
verify(deviceContext,times(1)).shutdownConnection();
}
*/
@Test
public void roleChangeOnDeviceTest3() {
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(deviceContext);
+ when(deviceManager.gainContext(deviceInfo)).thenReturn(deviceContext);
lifecycleConductor.roleChangeOnDevice(deviceInfo,true,ofpRole,true);
verify(deviceContext,times(0)).shutdownConnection();
}
@Test
public void roleChangeOnDeviceTest4() {
when(deviceContext.getDeviceState()).thenReturn(deviceState);
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(deviceContext);
+ when(deviceManager.gainContext(deviceInfo)).thenReturn(deviceContext);
when(deviceContext.onClusterRoleChange(OfpRole.BECOMEMASTER)).thenReturn(listenableFuture);
lifecycleConductor.roleChangeOnDevice(deviceInfo,true,OfpRole.BECOMEMASTER,false);
verify(statisticsManager).startScheduling(Mockito.<DeviceInfo>any());
@Test
public void roleChangeOnDeviceTest5() {
when(deviceContext.getDeviceState()).thenReturn(deviceState);
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(deviceContext);
+ when(deviceManager.gainContext(deviceInfo)).thenReturn(deviceContext);
when(deviceContext.onClusterRoleChange(OfpRole.BECOMESLAVE)).thenReturn(listenableFuture);
lifecycleConductor.roleChangeOnDevice(deviceInfo,true,OfpRole.BECOMESLAVE,false);
verify(statisticsManager).stopScheduling(Mockito.<DeviceInfo>any());
}
- /**
- * If getDeviceContext returns null nothing should happen
- */
- @Test
- public void gainVersionSafelyTest1() {
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(null);
- assertNull(lifecycleConductor.gainVersionSafely(deviceInfo));
- }
-
- /**
- * If getDeviceContext returns deviceContext getPrimaryConnectionContext() should be called
- */
- @Test
- public void gainVersionSafelyTest2() {
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(deviceContext);
- lifecycleConductor.gainVersionSafely(deviceInfo);
- verify(deviceContext,times(1)).getPrimaryConnectionContext();
- }
-
/**
* If getDeviceContext return null then null should be returned
*/
@Test
public void gainConnectionStateSafelyTest1() {
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(null);
+ when(deviceManager.gainContext(deviceInfo)).thenReturn(null);
assertNull(lifecycleConductor.gainConnectionStateSafely(deviceInfo));
}
*/
@Test
public void reserveXidForDeviceMessageTest1() {
- when(deviceManager.getDeviceContextFromNodeId(deviceInfo)).thenReturn(null);
+ when(deviceManager.gainContext(deviceInfo)).thenReturn(null);
assertNull(lifecycleConductor.reserveXidForDeviceMessage(deviceInfo));
}
Code Review / openflowplugin.git / commitdiff