3.2.x release (#177)

msohailhussain · Michael Ng · commit 38b3df32b872 · 2019-07-22T09:53:26.000-07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,17 @@
+## 3.2.0
+July 22nd, 2019
+
+ ### New Features:
+* Added support for automatic datafile management via `HttpProjectConfigManager` for framework 4.0 or above:
+  * The [`HttpProjectConfigManager`](https://github.com/optimizely/csharp-sdk/blob/master/OptimizelySDK/Config/HttpProjectConfigManager.cs) is an implementation of the abstract
+      [`PollingProjectConfigManager`](https://github.com/optimizely/csharp-sdk/blob/master/OptimizelySDK/Config/PollingProjectConfigManager.cs) class.
+    - Users must first build the `HttpProjectConfigManager` with an SDK key and then and provide that instance to the `Optimizely`.
+    - An initial datafile can be provided to the `HttpProjectConfigManager` to bootstrap before making http requests for the hosted datafile.
+    - Requests for the datafile are made in a separate thread and are scheduled with fixed delay.
+    - Configuration updates can be subscribed to via the NotificationCenter built with the `HttpProjectConfigManager`.
+    - `Optimizely` instance must be disposed after the use or `HttpProjectConfigManager` must be disposed after the use to release resources.
+- The [`OptimizelyFactory`](https://github.com/optimizely/csharp-sdk/blob/master/OptimizelySDK/OptimizelyFactory.cs) provides basic methods for instantiating the Optimizely SDK with a minimal number of parameters. Check [`README.md`](https://github.com/optimizely/csharp-sdk#use-optimizelyfactory) for more details.
+
 ## 3.1.1
 June 19th, 2019
 
diff --git a/OptimizelySDK.DemoApp/Properties/AssemblyInfo.cs b/OptimizelySDK.DemoApp/Properties/AssemblyInfo.cs
@@ -37,6 +37,6 @@
 //
 // You can specify all the values or you can default the Revision and Build Numbers
 // by using the '*' as shown below:
-[assembly: AssemblyVersion("3.1.1.0")]
-[assembly: AssemblyFileVersion("3.1.1.0")]
-[assembly: AssemblyInformationalVersion("3.1.1")] // Used by Nuget.
+[assembly: AssemblyVersion("3.2.0.0")]
+[assembly: AssemblyFileVersion("3.2.0.0")]
+[assembly: AssemblyInformationalVersion("3.2.0")] // Used by Nuget.
diff --git a/OptimizelySDK.DemoApp/packages.config b/OptimizelySDK.DemoApp/packages.config
@@ -17,7 +17,7 @@
   <package id="murmurhash-signed" version="1.0.2" targetFramework="net45" />
   <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net45" />
   <package id="NJsonSchema" version="8.30.6304.31883" targetFramework="net45" />
-  <package id="Optimizely.SDK" version="3.1.0" targetFramework="net45" />
+  <package id="Optimizely.SDK" version="3.2.0" targetFramework="net45" />
   <package id="popper.js" version="1.12.9" targetFramework="net45" />
   <package id="Respond" version="1.2.0" targetFramework="net45" />
   <package id="WebGrease" version="1.5.2" targetFramework="net45" />
diff --git a/OptimizelySDK.Net35/Properties/AssemblyInfo.cs b/OptimizelySDK.Net35/Properties/AssemblyInfo.cs
@@ -38,6 +38,6 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("3.1.1.0")]
-[assembly: AssemblyFileVersion("3.1.1.0")]
-[assembly: AssemblyInformationalVersion("3.1.1")] // Used by Nuget.
+[assembly: AssemblyVersion("3.2.0.0")]
+[assembly: AssemblyFileVersion("3.2.0.0")]
+[assembly: AssemblyInformationalVersion("3.2.0")] // Used by Nuget.
diff --git a/OptimizelySDK.Net40/Properties/AssemblyInfo.cs b/OptimizelySDK.Net40/Properties/AssemblyInfo.cs
@@ -38,6 +38,6 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("3.1.1.0")]
-[assembly: AssemblyFileVersion("3.1.1.0")]
-[assembly: AssemblyInformationalVersion("3.1.1")] // Used by Nuget.
+[assembly: AssemblyVersion("3.2.0.0")]
+[assembly: AssemblyFileVersion("3.2.0.0")]
+[assembly: AssemblyInformationalVersion("3.2.0")] // Used by Nuget.
diff --git a/OptimizelySDK.NetStandard16/Properties/AssemblyInfo.cs b/OptimizelySDK.NetStandard16/Properties/AssemblyInfo.cs
@@ -38,6 +38,6 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("3.1.1.0")]
-[assembly: AssemblyFileVersion("3.1.1.0")]
-[assembly: AssemblyInformationalVersion("3.1.1")] // Used by Nuget.
+[assembly: AssemblyVersion("3.2.0.0")]
+[assembly: AssemblyFileVersion("3.2.0.0")]
+[assembly: AssemblyInformationalVersion("3.2.0")] // Used by Nuget.
diff --git a/OptimizelySDK.Package/OptimizelySDK.nuspec b/OptimizelySDK.Package/OptimizelySDK.nuspec
@@ -2,7 +2,7 @@
 <package>
     <metadata>
         <id>Optimizely.SDK</id>
-        <version>3.1.0</version>
+        <version>3.2.0</version>
         <title>Optimizely C# SDK</title>
         <authors>Optimizely Development Team</authors>
         <owners>fullstack.optimizely</owners>
diff --git a/OptimizelySDK.Tests/ConfigTest/HttpProjectConfigManagerTest.cs b/OptimizelySDK.Tests/ConfigTest/HttpProjectConfigManagerTest.cs
@@ -130,7 +130,8 @@ public void TestHttpConfigManagerDoesNotWaitForTheConfigWhenDeferIsTrue()
                 .WithSdkKey("QBw9gFM8oTn7ogY9ANCC1z")
                 .WithLogger(LoggerMock.Object)
                 .WithPollingInterval(TimeSpan.FromSeconds(2))
-                .WithBlockingTimeoutPeriod(TimeSpan.FromSeconds(0))                                
+                // negligible timeout
+                .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(50))                                
                 .WithStartByDefault()
                 .Build(false);
 
@@ -176,6 +177,52 @@ public void TestHttpConfigManagerDoesNotSendConfigUpdateNotificationWhenDatafile
             NotificationCallbackMock.Verify(nc => nc.TestConfigUpdateCallback(), Times.Never);
             Assert.NotNull(httpManager.GetConfig()); Assert.NotNull(httpManager.GetConfig());
         }
-    #endregion
-}
+
+        [Test]
+        public void TestDefaultBlockingTimeoutWhileProvidingZero()
+        {                        
+            var httpManager = new HttpProjectConfigManager.Builder()
+                .WithSdkKey("QBw9gFM8oTn7ogY9ANCC1z")
+                .WithDatafile(TestData.Datafile)
+                .WithLogger(LoggerMock.Object)
+                .WithPollingInterval(TimeSpan.FromMilliseconds(1000))
+                .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(0))
+                .WithStartByDefault(true)
+                .Build(true);
+            
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, $"Blocking timeout is not valid, using default blocking timeout {TimeSpan.FromSeconds(15).TotalMilliseconds}ms"));
+        }
+
+        [Test]
+        public void TestDefaultPeriodWhileProvidingZero()
+        {
+            var httpManager = new HttpProjectConfigManager.Builder()
+                .WithSdkKey("QBw9gFM8oTn7ogY9ANCC1z")
+                .WithDatafile(TestData.Datafile)
+                .WithLogger(LoggerMock.Object)
+                .WithPollingInterval(TimeSpan.FromMilliseconds(0))
+                .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(1000))
+                .WithStartByDefault(true)
+                .Build(true);
+
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, $"Period is not valid for periodic calls, using default period {TimeSpan.FromMinutes(5).TotalMilliseconds}ms"));
+        }
+
+        [Test]
+        public void TestDefaultPeriodWhileProvidingNegative()
+        {
+            var httpManager = new HttpProjectConfigManager.Builder()
+                .WithSdkKey("QBw9gFM8oTn7ogY9ANCC1z")
+                .WithDatafile(TestData.Datafile)
+                .WithLogger(LoggerMock.Object)
+                .WithPollingInterval(TimeSpan.FromMilliseconds(-1))
+                .WithBlockingTimeoutPeriod(TimeSpan.FromMilliseconds(1000))
+                .WithStartByDefault(true)
+                .Build(true);
+
+            LoggerMock.Verify(l => l.Log(LogLevel.INFO, $"Period is not valid for periodic calls, using default period {TimeSpan.FromMinutes(5).TotalMilliseconds}ms"));            
+        }
+
+        #endregion
+    }
 }
diff --git a/OptimizelySDK.Tests/Properties/AssemblyInfo.cs b/OptimizelySDK.Tests/Properties/AssemblyInfo.cs
@@ -31,6 +31,6 @@
 //
 // You can specify all the values or you can default the Revision and Build Numbers
 // by using the '*' as shown below:
-[assembly: AssemblyVersion("3.1.1.0")]
-[assembly: AssemblyFileVersion("3.1.1.0")]
-[assembly: AssemblyInformationalVersion("3.1.1")] // Used by Nuget.
+[assembly: AssemblyVersion("3.2.0.0")]
+[assembly: AssemblyFileVersion("3.2.0.0")]
+[assembly: AssemblyInformationalVersion("3.2.0")] // Used by Nuget.
diff --git a/OptimizelySDK/Config/HttpProjectConfigManager.cs b/OptimizelySDK/Config/HttpProjectConfigManager.cs
@@ -122,14 +122,18 @@ protected override ProjectConfig Poll()
         
         public class Builder
         {
+            private const long MAX_MILLISECONDS_LIMIT = 4294967294;
+            private readonly TimeSpan DEFAULT_PERIOD = TimeSpan.FromMinutes(5);
+            private readonly TimeSpan DEFAULT_BLOCKINGOUT_PERIOD = TimeSpan.FromSeconds(15);
+
             private string Datafile;
             private string SdkKey;
             private string Url;
             private string Format = "https://cdn.optimizely.com/datafiles/{0}.json";
             private ILogger Logger;
             private IErrorHandler ErrorHandler;
-            private TimeSpan Period = TimeSpan.FromMinutes(5);
-            private TimeSpan BlockingTimeoutSpan = TimeSpan.FromSeconds(15);
+            private TimeSpan Period;
+            private TimeSpan BlockingTimeoutSpan;
             private bool AutoUpdate = true;
             private bool StartByDefault;
             private NotificationCenter NotificationCenter;
@@ -143,42 +147,49 @@ public Builder WithBlockingTimeoutPeriod(TimeSpan blockingTimeoutSpan)
             public Builder WithDatafile(string datafile)
             {
                 Datafile = datafile;
+
                 return this;
             }
 
             public Builder WithSdkKey(string sdkKey)
             {
                 SdkKey = sdkKey;
+
                 return this;
             }
 
             public Builder WithUrl(string url)
             {
                 Url = url;
+
                 return this;
             }
 
             public Builder WithPollingInterval(TimeSpan period)
-            {
+            {                
                 Period = period;
+
                 return this;
             }
 
             public Builder WithFormat(string format)
             {
                 Format = format;
+
                 return this;
             }
             
             public Builder WithLogger(ILogger logger)
             {
                 Logger = logger;
+
                 return this;
             }
 
             public Builder WithErrorHandler(IErrorHandler errorHandler)
             {
                 ErrorHandler = errorHandler;
+
                 return this;
             }
 
@@ -222,20 +233,35 @@ public HttpProjectConfigManager Build()
             public HttpProjectConfigManager Build(bool defer)
             {
                 HttpProjectConfigManager configManager = null;
+
                 if (Logger == null)
                     Logger = new DefaultLogger();
 
+                if (ErrorHandler == null)
+                    ErrorHandler = new DefaultErrorHandler();
+
                 if (string.IsNullOrEmpty(Url) && string.IsNullOrEmpty(SdkKey))
                 {
-                    ErrorHandler.HandleError(new Exception("SdkKey cannot be null"));
-                    throw new Exception("SdkKey cannot be null");
+                    ErrorHandler.HandleError(new Exception("SdkKey cannot be null"));                    
                 }
                 else if (!string.IsNullOrEmpty(SdkKey))
                 {
                     Url = string.Format(Format, SdkKey);
                 }
+
+                if (Period.TotalMilliseconds <= 0 || Period.TotalMilliseconds > MAX_MILLISECONDS_LIMIT) {
+                    Logger.Log(LogLevel.INFO, $"Period is not valid for periodic calls, using default period {DEFAULT_PERIOD.TotalMilliseconds}ms");
+                    Period = DEFAULT_PERIOD;
+                }
                     
 
+                if (BlockingTimeoutSpan.TotalMilliseconds <= 0 || BlockingTimeoutSpan.TotalMilliseconds > MAX_MILLISECONDS_LIMIT) {
+                    Logger.Log(LogLevel.INFO, $"Blocking timeout is not valid, using default blocking timeout {DEFAULT_BLOCKINGOUT_PERIOD.TotalMilliseconds}ms");
+                    BlockingTimeoutSpan = DEFAULT_BLOCKINGOUT_PERIOD;
+                }
+                    
+
+
                 configManager = new HttpProjectConfigManager(Period, Url, BlockingTimeoutSpan, AutoUpdate, Logger, ErrorHandler);
 
                 if (Datafile != null)
diff --git a/OptimizelySDK/Config/PollingProjectConfigManager.cs b/OptimizelySDK/Config/PollingProjectConfigManager.cs
@@ -136,15 +136,7 @@ public ProjectConfig GetConfig()
         /// <param name="projectConfig">ProjectConfig</param>
         /// <returns>true if the ProjectConfig saved successfully, false otherwise</returns>
         public bool SetConfig(ProjectConfig projectConfig)
-        {
-            // trigger now, due because of delayed latency response
-            if (scheduleWhenFinished && IsStarted) {
-                // Can't directly call Run, it will be part of previous thread then.
-                // Call immediately, because it's due now.
-                scheduleWhenFinished = false;
-                SchedulerService.Change(TimeSpan.FromSeconds(0), PollingInterval);
-            }
-
+        {            
             if (projectConfig == null)
                 return false;
                 
@@ -191,6 +183,13 @@ public virtual void Run()
                     Logger.Log(LogLevel.ERROR, "Unable to get project config. Error: " + exception.GetAllMessages());
                 } finally {
                     Interlocked.Exchange(ref resourceInUse, 0);
+
+                    // trigger now, due because of delayed latency response
+                    if (scheduleWhenFinished && IsStarted) {                        
+                        // Call immediately, because it's due now.
+                        scheduleWhenFinished = false;
+                        SchedulerService.Change(TimeSpan.FromSeconds(0), PollingInterval);
+                    }
                 }
             }
             else {
diff --git a/OptimizelySDK/Properties/AssemblyInfo.cs b/OptimizelySDK/Properties/AssemblyInfo.cs
@@ -38,6 +38,6 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("3.1.1.0")]
-[assembly: AssemblyFileVersion("3.1.1.0")]
-[assembly: AssemblyInformationalVersion("3.1.1")] // Used by Nuget.
+[assembly: AssemblyVersion("3.2.0.0")]
+[assembly: AssemblyFileVersion("3.2.0.0")]
+[assembly: AssemblyInformationalVersion("3.2.0")] // Used by Nuget.
diff --git a/README.md b/README.md
@@ -67,9 +67,77 @@ The Optimizely client object accepts the following plug-ins:
 1. `IEventDispatcher` handles the HTTP requests to Optimizely.  The default implementation is an asynchronous "fire and forget".
 2. `ILogger` exposes a single method, Log, to record activity in the SDK.  An example of a class to bridge the SDK's Log to Log4Net is provided in the Demo Application.
 3. `IErrorHandler` allows you to implement custom logic when Exceptions are thrown.  Note that Exception information is already included in the Log.
+4. `ProjectConfigManager` exposes method for retrieving ProjectConfig instance. Examples include `FallbackProjectConfigManager` and `HttpProjectConfigManager`.
 
 These are optional plug-ins and default behavior is implement if none are provided.
 
+#### OptimizelyFactory
+
+[`OptimizelyFactory`](https://github.com/optimizely/csharp-sdk/blob/master/OptimizelySDK/OptimizelyFactory.cs)
+provides basic utility to instantiate the Optimizely SDK with a minimal number of configuration options.
+
+`OptimizelyFactory` does not capture all configuration and initialization options. For more use cases,
+build the resources via their respective builder classes.
+
+##### Use OptimizelyFactory
+
+You must provide the SDK key at runtime, either directly via the factory method:
+```
+Optimizely optimizely = OptimizelyFactory.newDefaultInstance(<<SDK_KEY>>);
+```
+
+You can also provide default datafile with the SDK key.
+```
+Optimizely optimizely = OptimizelyFactory.newDefaultInstance(<<SDK_KEY>>, <<Fallback>>);
+```
+
+#### HttpProjectConfigManager
+
+[`HttpProjectConfigManager`](https://github.com/optimizely/csharp-sdk/blob/master/OptimizelySDK/Config/HttpProjectConfigManager.cs)
+is an implementation of the abstract [`PollingProjectConfigManager`](https://github.com/optimizely/csharp-sdk/blob/master/OptimizelySDK/Config/PollingProjectConfigManager.cs).
+The `Poll` method is extended and makes an HTTP GET request to the configured URL to asynchronously download the
+project datafile and initialize an instance of the ProjectConfig.
+
+By default, `HttpProjectConfigManager` will block until the first successful datafile retrieval, up to a configurable timeout.
+Set the frequency of the polling method and the blocking timeout with `HttpProjectConfigManager.Builder`.
+
+##### Use HttpProjectConfigManager
+
+```
+HttpProjectConfigManager httpManager = new HttpProjectConfigManager.Builder()
+	.WithSdkKey(sdkKey)
+	.WithPollingInterval(TimeSpan.FromMinutes(1))
+	.Build();
+```
+
+##### SDK key
+
+The SDK key is used to compose the outbound HTTP request to the default datafile location on the Optimizely CDN.
+
+##### Polling interval
+
+The polling interval is used to specify a fixed delay between consecutive HTTP requests for the datafile. Between 1 to 4294967294 miliseconds is valid duration. Otherwise default 5 minutes will be used.
+
+##### Blocking Timeout Period
+
+The blocking timeout period is used to specify a maximum time to wait for initial bootstrapping. Between 1 to 4294967294 miliseconds is valid blocking timeout period. Otherwise default value 15 seconds will be used.
+
+##### Initial datafile
+
+You can provide an initial datafile via the builder to bootstrap the `ProjectConfigManager` so that it can be used immediately without blocking execution.
+
+##### URL
+
+The URL is used to specify the location of datafile.
+
+##### Format
+
+This option enables user to provide a custom URL format to fetch the datafile.
+
+##### Start by default
+
+This option is used to specify whether to start the config manager on initialization.
+
 ## Development
 
 ### Unit tests

Original file line number	Diff line number	Diff line change
`@@ -122,14 +122,18 @@ protected override ProjectConfig Poll()`
`122`	`122`
`123`	`123`	`public class Builder`
`124`	`124`	`{`
	`125`	`+ private const long MAX_MILLISECONDS_LIMIT = 4294967294;`
	`126`	`+ private readonly TimeSpan DEFAULT_PERIOD = TimeSpan.FromMinutes(5);`
	`127`	`+ private readonly TimeSpan DEFAULT_BLOCKINGOUT_PERIOD = TimeSpan.FromSeconds(15);`
	`128`	`+`
`125`	`129`	`private string Datafile;`
`126`	`130`	`private string SdkKey;`
`127`	`131`	`private string Url;`
`128`	`132`	`private string Format = "https://cdn.optimizely.com/datafiles/{0}.json";`
`129`	`133`	`private ILogger Logger;`
`130`	`134`	`private IErrorHandler ErrorHandler;`
`131`		`- private TimeSpan Period = TimeSpan.FromMinutes(5);`
`132`		`- private TimeSpan BlockingTimeoutSpan = TimeSpan.FromSeconds(15);`
	`135`	`+ private TimeSpan Period;`
	`136`	`+ private TimeSpan BlockingTimeoutSpan;`
`133`	`137`	`private bool AutoUpdate = true;`
`134`	`138`	`private bool StartByDefault;`
`135`	`139`	`private NotificationCenter NotificationCenter;`
`@@ -143,42 +147,49 @@ public Builder WithBlockingTimeoutPeriod(TimeSpan blockingTimeoutSpan)`
`143`	`147`	`public Builder WithDatafile(string datafile)`
`144`	`148`	`{`
`145`	`149`	`Datafile = datafile;`
	`150`	`+`
`146`	`151`	`return this;`
`147`	`152`	`}`
`148`	`153`
`149`	`154`	`public Builder WithSdkKey(string sdkKey)`
`150`	`155`	`{`
`151`	`156`	`SdkKey = sdkKey;`
	`157`	`+`
`152`	`158`	`return this;`
`153`	`159`	`}`
`154`	`160`
`155`	`161`	`public Builder WithUrl(string url)`
`156`	`162`	`{`
`157`	`163`	`Url = url;`
	`164`	`+`
`158`	`165`	`return this;`
`159`	`166`	`}`
`160`	`167`
`161`	`168`	`public Builder WithPollingInterval(TimeSpan period)`
`162`		`- {`
	`169`	`+ {`
`163`	`170`	`Period = period;`
	`171`	`+`
`164`	`172`	`return this;`
`165`	`173`	`}`
`166`	`174`
`167`	`175`	`public Builder WithFormat(string format)`
`168`	`176`	`{`
`169`	`177`	`Format = format;`
	`178`	`+`
`170`	`179`	`return this;`
`171`	`180`	`}`
`172`	`181`
`173`	`182`	`public Builder WithLogger(ILogger logger)`
`174`	`183`	`{`
`175`	`184`	`Logger = logger;`
	`185`	`+`
`176`	`186`	`return this;`
`177`	`187`	`}`
`178`	`188`
`179`	`189`	`public Builder WithErrorHandler(IErrorHandler errorHandler)`
`180`	`190`	`{`
`181`	`191`	`ErrorHandler = errorHandler;`
	`192`	`+`
`182`	`193`	`return this;`
`183`	`194`	`}`
`184`	`195`
`@@ -222,20 +233,35 @@ public HttpProjectConfigManager Build()`
`222`	`233`	`public HttpProjectConfigManager Build(bool defer)`
`223`	`234`	`{`
`224`	`235`	`HttpProjectConfigManager configManager = null;`
	`236`	`+`
`225`	`237`	`if (Logger == null)`
`226`	`238`	`Logger = new DefaultLogger();`
`227`	`239`
	`240`	`+ if (ErrorHandler == null)`
	`241`	`+ ErrorHandler = new DefaultErrorHandler();`
	`242`	`+`
`228`	`243`	`if (string.IsNullOrEmpty(Url) && string.IsNullOrEmpty(SdkKey))`
`229`	`244`	`{`
`230`		`- ErrorHandler.HandleError(new Exception("SdkKey cannot be null"));`
`231`		`- throw new Exception("SdkKey cannot be null");`
	`245`	`+ ErrorHandler.HandleError(new Exception("SdkKey cannot be null"));`
`232`	`246`	`}`
`233`	`247`	`else if (!string.IsNullOrEmpty(SdkKey))`
`234`	`248`	`{`
`235`	`249`	`Url = string.Format(Format, SdkKey);`
`236`	`250`	`}`
	`251`	`+`
	`252`	`+ if (Period.TotalMilliseconds <= 0 \|\| Period.TotalMilliseconds > MAX_MILLISECONDS_LIMIT) {`
	`253`	`+ Logger.Log(LogLevel.INFO, $"Period is not valid for periodic calls, using default period {DEFAULT_PERIOD.TotalMilliseconds}ms");`
	`254`	`+ Period = DEFAULT_PERIOD;`
	`255`	`+ }`
`237`	`256`
`238`	`257`
	`258`	`+ if (BlockingTimeoutSpan.TotalMilliseconds <= 0 \|\| BlockingTimeoutSpan.TotalMilliseconds > MAX_MILLISECONDS_LIMIT) {`
	`259`	`+ Logger.Log(LogLevel.INFO, $"Blocking timeout is not valid, using default blocking timeout {DEFAULT_BLOCKINGOUT_PERIOD.TotalMilliseconds}ms");`
	`260`	`+ BlockingTimeoutSpan = DEFAULT_BLOCKINGOUT_PERIOD;`
	`261`	`+ }`
	`262`	`+`
	`263`	`+`
	`264`	`+`
`239`	`265`	`configManager = new HttpProjectConfigManager(Period, Url, BlockingTimeoutSpan, AutoUpdate, Logger, ErrorHandler);`
`240`	`266`
`241`	`267`	`if (Datafile != null)`