boolean isSwitchFeaturesMandatory();
- boolean isStatisticsPollingOff();
+ boolean isStatisticsPollingOn();
- void setIsStatisticsPollingOff(final boolean isStatisticsPollingOff);
+ void setIsStatisticsPollingOn(final boolean isStatisticsPollingOn);
/**
* Backward compatibility feature - exposing rpc for statistics polling (result is provided in form of async notification)
@Override
void close();
- void setIsStatisticsPollingOff(boolean isStatisticsPollingOff);
+ void setIsStatisticsPollingOn(boolean isStatisticsPollingOn);
}
default 64000;
}
- leaf is-statistics-polling-off {
+ leaf is-statistics-polling-on {
type boolean;
- default "false";
+ default "true";
}
leaf is-statistics-rpc-enabled {
echo-reply-timeout=2000
#flag to turn on/off statistics polling
#can be changed on demand
-#Turned on by default. Default value is false
-is-statistics-polling-off=false
+#Turned on by default. Default value is true
+is-statistics-polling-on=true
<rpc-requests-quota>20000</rpc-requests-quota>
<switch-features-mandatory>false</switch-features-mandatory>
<global-notification-quota>64000</global-notification-quota>
- <is-statistics-polling-off>false</is-statistics-polling-off>
+ <is-statistics-polling-on>true</is-statistics-polling-on>
<barrier-interval-timeout-limit>500</barrier-interval-timeout-limit>
<barrier-count-limit>25600</barrier-count-limit>
<echo-reply-timeout>2000</echo-reply-timeout>
openflowPluginProvider.setNotificationProviderService(notificationService);
openflowPluginProvider.setNotificationPublishService(notificationPublishService);
openflowPluginProvider.setSwitchFeaturesMandatory(providerConfig.isSwitchFeaturesMandatory());
- openflowPluginProvider.setIsStatisticsPollingOff(providerConfig.isIsStatisticsPollingOff());
+ openflowPluginProvider.setIsStatisticsPollingOn(providerConfig.isIsStatisticsPollingOn());
openflowPluginProvider.setIsStatisticsRpcEnabled(providerConfig.isIsStatisticsRpcEnabled());
openflowPluginProvider.setBarrierCountLimit(providerConfig.getBarrierCountLimit().getValue());
openflowPluginProvider.setBarrierInterval(providerConfig.getBarrierIntervalTimeoutLimit().getValue());
openflowPluginProvider.initialize();
LOG.info("Configured values, " +
- "StatisticsPollingOff:{}, " +
+ "StatisticsPollingOn:{}, " +
"SwitchFeaturesMandatory:{}, " +
"BarrierCountLimit:{}, " +
"BarrierTimeoutLimit:{}, " +
"ThreadPoolMaxThreads:{}, " +
"ThreadPoolTimeout:{}, " +
"NotificationFlowRemovedOff:{}",
- providerConfig.isIsStatisticsPollingOff(),
+ providerConfig.isIsStatisticsPollingOn(),
providerConfig.isSwitchFeaturesMandatory(),
providerConfig.getBarrierCountLimit().getValue(),
providerConfig.getBarrierIntervalTimeoutLimit().getValue(),
private DataBroker dataBroker;
private Collection<SwitchConnectionProvider> switchConnectionProviders;
private boolean switchFeaturesMandatory = false;
- private boolean isStatisticsPollingOff = false;
+ private boolean isStatisticsPollingOn = true;
private boolean isStatisticsRpcEnabled;
private boolean isNotificationFlowRemovedOff = false;
private boolean skipTableFeatures = true;
}
@Override
- public boolean isStatisticsPollingOff() {
- return isStatisticsPollingOff;
+ public boolean isStatisticsPollingOn() {
+ return isStatisticsPollingOn;
}
@Override
- public void setIsStatisticsPollingOff(final boolean isStatisticsPollingOff) {
- this.isStatisticsPollingOff = isStatisticsPollingOff;
+ public void setIsStatisticsPollingOn(final boolean isStatisticsPollingOn) {
+ this.isStatisticsPollingOn = isStatisticsPollingOn;
}
private void startSwitchConnections() {
((ExtensionConverterProviderKeeper) deviceManager).setExtensionConverterProvider(extensionConverterManager);
rpcManager = new RpcManagerImpl(rpcProviderRegistry, rpcRequestsQuota, extensionConverterManager, convertorManager, notificationPublishService);
- statisticsManager = new StatisticsManagerImpl(rpcProviderRegistry, isStatisticsPollingOff, hashedWheelTimer, convertorManager);
+ statisticsManager = new StatisticsManagerImpl(rpcProviderRegistry, isStatisticsPollingOn, hashedWheelTimer, convertorManager);
/* Initialization Phase ordering - OFP Device Context suite */
// CM -> DM -> SM -> RPC -> Role -> DM
}
}
- if(statisticsManager != null && props.containsKey("is-statistics-polling-off")){
- statisticsManager.setIsStatisticsPollingOff(Boolean.valueOf(props.get("is-statistics-polling-off").toString()));
+ if(statisticsManager != null && props.containsKey("is-statistics-polling-on")){
+ statisticsManager.setIsStatisticsPollingOn(Boolean.valueOf(props.get("is-statistics-polling-on").toString()));
}
}
private final DeviceContext deviceContext;
private final DeviceState devState;
private final ListenableFuture<Boolean> emptyFuture;
- private final boolean shuttingDownStatisticsPolling;
+ private final boolean isStatisticsPollingOn;
private final SinglePurposeMultipartReplyTranslator multipartReplyTranslator;
private final Object collectionStatTypeLock = new Object();
@GuardedBy("collectionStatTypeLock")
private ListenableFuture<Boolean> lastDataGathering;
StatisticsContextImpl(@Nonnull final DeviceInfo deviceInfo,
- final boolean shuttingDownStatisticsPolling,
+ final boolean isStatisticsPollingOn,
@Nonnull final LifecycleService lifecycleService,
@Nonnull final ConvertorExecutor convertorExecutor,
@Nonnull final StatisticsManager myManager) {
this.lifecycleService = lifecycleService;
this.deviceContext = lifecycleService.getDeviceContext();
this.devState = Preconditions.checkNotNull(deviceContext.getDeviceState());
- this.shuttingDownStatisticsPolling = shuttingDownStatisticsPolling;
+ this.isStatisticsPollingOn = isStatisticsPollingOn;
multipartReplyTranslator = new SinglePurposeMultipartReplyTranslator(convertorExecutor);
emptyFuture = Futures.immediateFuture(false);
statisticsGatheringService = new StatisticsGatheringService(this, deviceContext);
private ListenableFuture<Boolean> gatherDynamicData(final boolean initial) {
this.lastDataGathering = null;
- if (shuttingDownStatisticsPolling) {
+ if (!isStatisticsPollingOn) {
LOG.debug("Statistics for device {} is not enabled.", getDeviceInfo().getNodeId().getValue());
return Futures.immediateFuture(Boolean.TRUE);
}
}
});
- if (!this.shuttingDownStatisticsPolling) {
+ if (this.isStatisticsPollingOn) {
myManager.startScheduling(deviceInfo);
}
public void setInitialSubmitHandler(final ClusterInitializationPhaseHandler initialSubmitHandler) {
this.initialSubmitHandler = initialSubmitHandler;
}
-}
+}
\ No newline at end of file
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
-import java.util.concurrent.CancellationException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Future;
private StatisticsWorkMode workMode = StatisticsWorkMode.COLLECTALL;
private final Semaphore workModeGuard = new Semaphore(1, true);
- private boolean isStatisticsPollingOff;
+ private boolean isStatisticsPollingOn;
private BindingAwareBroker.RpcRegistration<StatisticsManagerControlService> controlServiceRegistration;
private final HashedWheelTimer hashedWheelTimer;
}
public StatisticsManagerImpl(final RpcProviderRegistry rpcProviderRegistry,
- final boolean isStatisticsPollingOff,
+ final boolean isStatisticsPollingOn,
final HashedWheelTimer hashedWheelTimer,
final ConvertorExecutor convertorExecutor) {
Preconditions.checkArgument(rpcProviderRegistry != null);
this.controlServiceRegistration = Preconditions.checkNotNull(
rpcProviderRegistry.addRpcImplementation(StatisticsManagerControlService.class, this)
);
- this.isStatisticsPollingOff = isStatisticsPollingOff;
+ this.isStatisticsPollingOn = isStatisticsPollingOn;
this.hashedWheelTimer = hashedWheelTimer;
}
final StatisticsContext statisticsContext =
new StatisticsContextImpl(
deviceInfo,
- isStatisticsPollingOff,
+ isStatisticsPollingOn,
lifecycleService,
converterExecutor,
this);
if (LOG.isDebugEnabled()) {
LOG.debug("SCHEDULING NEXT STATISTICS POLLING for device: {}", deviceInfo.getNodeId());
}
- if (!isStatisticsPollingOff) {
+ if (isStatisticsPollingOn) {
final Timeout pollTimeout = hashedWheelTimer.newTimeout(
timeout -> pollStatistics(
deviceState,
if (workModeGuard.tryAcquire()) {
final StatisticsWorkMode targetWorkMode = input.getMode();
if (!workMode.equals(targetWorkMode)) {
- isStatisticsPollingOff = StatisticsWorkMode.FULLYDISABLED.equals(targetWorkMode);
+ isStatisticsPollingOn = !(StatisticsWorkMode.FULLYDISABLED.equals(targetWorkMode));
// iterate through stats-ctx: propagate mode
for (Map.Entry<DeviceInfo, StatisticsContext> entry : contexts.entrySet()) {
final DeviceInfo deviceInfo = entry.getKey();
@Override
public void startScheduling(final DeviceInfo deviceInfo) {
- if (isStatisticsPollingOff) {
+ if (!isStatisticsPollingOn) {
LOG.info("Statistics are shutdown for device: {}", deviceInfo.getNodeId());
return;
}
}
@Override
- public void setIsStatisticsPollingOff(boolean isStatisticsPollingOff){
- this.isStatisticsPollingOff = isStatisticsPollingOff;
+ public void setIsStatisticsPollingOn(boolean isStatisticsPollingOn){
+ this.isStatisticsPollingOn = isStatisticsPollingOn;
}
}
\ No newline at end of file
type uint32;
default 131072;
}
- leaf is-statistics-polling-off {
+ leaf is-statistics-polling-on {
type boolean;
- default "false";
+ default "true";
}
leaf is-statistics-rpc-enabled {
status deprecated;
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
final ConvertorManager convertorManager = ConvertorManagerFactory.createDefaultManager();
- final StatisticsContextImpl statisticsContext = new StatisticsContextImpl(mockedDeviceInfo, false, lifecycleService ,convertorManager, mockedStatisticsManager);
+ final StatisticsContextImpl statisticsContext = new StatisticsContextImpl(mockedDeviceInfo, true, lifecycleService ,convertorManager, mockedStatisticsManager);
final ListenableFuture<RpcResult<List<MultipartReply>>> rpcResult = immediateFuture(RpcResultBuilder.success(Collections.<MultipartReply>emptyList()).build());
when(mockedStatisticsGatheringService.getStatisticsOfType(any(EventIdentifier.class), any(MultipartType
}
-}
+}
\ No newline at end of file
}
private void initStatisticsContext() {
- statisticsContext = new StatisticsContextImpl(mockedDeviceInfo, false, lifecycleService, convertorManager, mockedStatisticsManager);
+ statisticsContext = new StatisticsContextImpl(mockedDeviceInfo, true, lifecycleService, convertorManager, mockedStatisticsManager);
statisticsContext.setStatisticsGatheringService(mockedStatisticsGatheringService);
statisticsContext.setStatisticsGatheringOnTheFlyService(mockedStatisticsOnFlyGatheringService);
}
*/
@Test
public void testClose() throws Exception {
- final StatisticsContextImpl statisticsContext = new StatisticsContextImpl(mockedDeviceInfo, false, lifecycleService, convertorManager, mockedStatisticsManager);
+ final StatisticsContextImpl statisticsContext = new StatisticsContextImpl(mockedDeviceInfo, true, lifecycleService, convertorManager, mockedStatisticsManager);
final RequestContext<Object> requestContext = statisticsContext.createRequestContext();
statisticsContext.close();
try {
Assert.fail("connection in state HANDSHAKING should NOT have caused exception here");
}
}
-}
+}
\ No newline at end of file