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.NotificationService;
-import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.openflowjava.protocol.spi.connection.SwitchConnectionProvider;
void setClusteringSingletonServicesProvider(ClusterSingletonServiceProvider singletonServicesProvider);
void setSkipTableFeatures(boolean skipTableFeatures);
+
+ void setBasicTimerDelay(long basicTimerDelay);
+
+ void setMaximumTimerDelay(long maximumTimerDelay);
}
void setIsStatisticsPollingOn(boolean isStatisticsPollingOn);
+ void setBasicTimerDelay(final long basicTimerDelay);
+
+ void setMaximumTimerDelay(final long maximumTimerDelay);
+
}
type boolean;
default "true";
}
+
+ leaf basic-timer-delay {
+ description "initial delay used in polling the statistics, value is in milliseconds";
+ type non-zero-uint32-type;
+ default 3000;
+ }
+
+ leaf maximum-timer-delay {
+ description "maximum timer delay is the wait time to collect next statistics
+ used in polling the statistics, value is in milliseconds";
+ type non-zero-uint32-type;
+ default 900000;
+ }
}
}
\ No newline at end of file
#can be changed on demand
#Turned on by default. Default value is true
is-statistics-polling-on=true
+#Default value of basic-timer-delay is 3000
+#basic timer delay is the initial delay used in polling the statistics, value is in milliseconds
+basic-timer-delay=3000
+#Default value of maximum-timer-delay is 900000
+#maximum timer delay is the wait time to collect next statistics
+#used in polling the statistics, value is in milliseconds
+maximum-timer-delay=900000
openflowPluginProvider.setStatisticsPollingOn(providerConfig.isIsStatisticsPollingOn());
openflowPluginProvider.setClusteringSingletonServicesProvider(singletonServiceProvider);
openflowPluginProvider.setSkipTableFeatures(providerConfig.isSkipTableFeatures());
+ openflowPluginProvider.setBasicTimerDelay(providerConfig.getBasicTimerDelay().getValue());
+ openflowPluginProvider.setMaximumTimerDelay(providerConfig.getMaximumTimerDelay().getValue());
openflowPluginProvider.initialize();
"ThreadPoolMinThreads:{}, " +
"ThreadPoolMaxThreads:{}, " +
"ThreadPoolTimeout:{}, " +
- "NotificationFlowRemovedOff:{}",
+ "NotificationFlowRemovedOff:{}, " +
+ "BasicTimerDelay:{}, "+
+ "MaximumTimerDelay:{} ",
providerConfig.isIsStatisticsPollingOn(),
providerConfig.isSwitchFeaturesMandatory(),
providerConfig.getBarrierCountLimit().getValue(),
providerConfig.getThreadPoolMinThreads(),
providerConfig.getThreadPoolMaxThreads().getValue(),
providerConfig.getThreadPoolTimeout(),
- providerConfig.isEnableFlowRemovedNotification());
+ providerConfig.isEnableFlowRemovedNotification(),
+ providerConfig.getBasicTimerDelay().getValue(),
+ providerConfig.getMaximumTimerDelay().getValue());
return openflowPluginProvider;
}
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.HashedWheelTimer;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.Collection;
import org.opendaylight.openflowplugin.openflow.md.core.session.OFSessionUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import io.netty.util.HashedWheelTimer;
public class OpenFlowPluginProviderImpl implements OpenFlowPluginProvider, OpenFlowPluginExtensionRegistratorProvider {
private boolean isStatisticsRpcEnabled;
private boolean isFlowRemovedNotificationOn = true;
private boolean skipTableFeatures = true;
+ private long basicTimerDelay;
+ private long maximumTimerDelay;
private final ThreadPoolExecutor threadPool;
private ClusterSingletonServiceProvider singletonServicesProvider;
this.skipTableFeatures = skipTableFeatures;
}
+ @Override
+ public void setBasicTimerDelay(long basicTimerDelay) {
+ this.basicTimerDelay = basicTimerDelay;
+ }
+
+ @Override
+ public void setMaximumTimerDelay(long maximumTimerDelay) {
+ this.maximumTimerDelay = maximumTimerDelay;
+ }
+
@Override
public void setSwitchFeaturesMandatory(final boolean switchFeaturesMandatory) {
this.switchFeaturesMandatory = switchFeaturesMandatory;
((ExtensionConverterProviderKeeper) deviceManager).setExtensionConverterProvider(extensionConverterManager);
rpcManager = new RpcManagerImpl(rpcProviderRegistry, rpcRequestsQuota, extensionConverterManager, convertorManager, notificationPublishService);
- statisticsManager = new StatisticsManagerImpl(rpcProviderRegistry, isStatisticsPollingOn, hashedWheelTimer, convertorManager);
+ statisticsManager = new StatisticsManagerImpl(rpcProviderRegistry, isStatisticsPollingOn, hashedWheelTimer,
+ convertorManager,basicTimerDelay,maximumTimerDelay);
/* Initialization Phase ordering - OFP Device Context suite */
// CM -> DM -> SM -> RPC -> Role -> DM
if(statisticsManager != null && props.containsKey("is-statistics-polling-on")){
statisticsManager.setIsStatisticsPollingOn(Boolean.valueOf(props.get("is-statistics-polling-on").toString()));
}
+
+ if(statisticsManager != null && props.containsKey("basic-timer-delay")){
+ statisticsManager.setBasicTimerDelay(Long.valueOf(props.get("basic-timer-delay").toString()));
+ }
+
+ if(statisticsManager != null && props.containsKey("maximum-timer-delay")){
+ statisticsManager.setMaximumTimerDelay(Long.valueOf(props.get("maximum-timer-delay").toString()));
+ }
}
private final ConcurrentMap<DeviceInfo, StatisticsContext> contexts = new ConcurrentHashMap<>();
- private static final long basicTimerDelay = 3000;
- private static long currentTimerDelay = basicTimerDelay;
- private static final long maximumTimerDelay = 900000; //wait max 15 minutes for next statistics
+ private static long basicTimerDelay;
+ private static long currentTimerDelay;
+ private static long maximumTimerDelay; //wait time for next statistics
private StatisticsWorkMode workMode = StatisticsWorkMode.COLLECTALL;
private final Semaphore workModeGuard = new Semaphore(1, true);
public StatisticsManagerImpl(final RpcProviderRegistry rpcProviderRegistry,
final boolean isStatisticsPollingOn,
final HashedWheelTimer hashedWheelTimer,
- final ConvertorExecutor convertorExecutor) {
+ final ConvertorExecutor convertorExecutor,
+ final long basicTimerDelay,
+ final long maximumTimerDelay) {
Preconditions.checkArgument(rpcProviderRegistry != null);
this.converterExecutor = convertorExecutor;
this.controlServiceRegistration = Preconditions.checkNotNull(
rpcProviderRegistry.addRpcImplementation(StatisticsManagerControlService.class, this)
);
this.isStatisticsPollingOn = isStatisticsPollingOn;
+ this.basicTimerDelay = basicTimerDelay;
+ this.currentTimerDelay = basicTimerDelay;
+ this.maximumTimerDelay = maximumTimerDelay;
this.hashedWheelTimer = hashedWheelTimer;
}
contexts.remove(deviceInfo);
LOG.debug("Statistics context removed for node {}", deviceInfo.getLOGValue());
}
+
+ @Override
+ public void setBasicTimerDelay(final long basicTimerDelay) {
+ this.basicTimerDelay = basicTimerDelay;
+ }
+
+ @Override
+ public void setMaximumTimerDelay(final long maximumTimerDelay) {
+ this.maximumTimerDelay = maximumTimerDelay;
+ }
}
Matchers.<StatisticsManagerControlService>any())).thenReturn(serviceControlRegistration);
final ConvertorManager convertorManager = ConvertorManagerFactory.createDefaultManager();
- statisticsManager = new StatisticsManagerImpl(rpcProviderRegistry, false, new HashedWheelTimer(), convertorManager);
+ final long basicTimerDelay = 3000L;
+ final long maximumTimerDelay = 900000L;
+ statisticsManager = new StatisticsManagerImpl(rpcProviderRegistry, false, new HashedWheelTimer(),
+ convertorManager, basicTimerDelay, maximumTimerDelay);
statisticsManager.setDeviceInitializationPhaseHandler(deviceInitializationPhaseHandler);
}