Updating terminology used in the host

fabiocav · fabiocav · commit 8281ff07e77d · 2020-08-12T09:55:35.000-07:00
diff --git a/src/WebJobs.Script.WebHost/Management/WebFunctionsManager.cs b/src/WebJobs.Script.WebHost/Management/WebFunctionsManager.cs
@@ -72,7 +72,7 @@ internal IEnumerable<FunctionMetadata> GetFunctionsMetadata(bool includeProxies,
                 filterPredicate = m => m.IsProxy() || !m.IsCodeless();
             }
 
-            return _functionMetadataManager.GetFunctionMetadata(forceRefresh, applyWhitelist: false).Where(filterPredicate);
+            return _functionMetadataManager.GetFunctionMetadata(forceRefresh, applyAllowlist: false).Where(filterPredicate);
         }
 
         /// <summary>
diff --git a/src/WebJobs.Script/Host/FunctionMetadataManager.cs b/src/WebJobs.Script/Host/FunctionMetadataManager.cs
@@ -75,30 +75,30 @@ public bool TryGetFunctionMetadata(string functionName, out FunctionMetadata fun
         /// Gets the function metadata array from all providers.
         /// </summary>
         /// <param name="forceRefresh">Forces reload from all providers.</param>
-        /// <param name="applyWhitelist">Apply functions whitelist filter.</param>
+        /// <param name="applyAllowList">Apply functions allow list filter.</param>
         /// <returns> An Immmutable array of FunctionMetadata.</returns>
-        public ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh, bool applyWhitelist = true)
+        public ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh, bool applyAllowList = true)
         {
             if (forceRefresh || _servicesReset || _functionMetadataArray.IsDefaultOrEmpty)
             {
                 _functionMetadataArray = LoadFunctionMetadata(forceRefresh);
-                _logger.FunctionMetadataManagerFunctionsLoaded(ApplyWhitelist(_functionMetadataArray).Count());
+                _logger.FunctionMetadataManagerFunctionsLoaded(ApplyAllowList(_functionMetadataArray).Count());
                 _servicesReset = false;
             }
 
-            return applyWhitelist ? ApplyWhitelist(_functionMetadataArray) : _functionMetadataArray;
+            return applyAllowList ? ApplyAllowList(_functionMetadataArray) : _functionMetadataArray;
         }
 
-        private ImmutableArray<FunctionMetadata> ApplyWhitelist(ImmutableArray<FunctionMetadata> metadataList)
+        private ImmutableArray<FunctionMetadata> ApplyAllowList(ImmutableArray<FunctionMetadata> metadataList)
         {
-            var whitelist = _scriptOptions.Value?.Functions;
+            var allowList = _scriptOptions.Value?.Functions;
 
-            if (whitelist == null || metadataList.IsDefaultOrEmpty)
+            if (allowList == null || metadataList.IsDefaultOrEmpty)
             {
                 return metadataList;
             }
 
-            return metadataList.Where(metadata => whitelist.Any(functionName => functionName.Equals(metadata.Name, StringComparison.CurrentCultureIgnoreCase))).ToImmutableArray();
+            return metadataList.Where(metadata => allowList.Any(functionName => functionName.Equals(metadata.Name, StringComparison.CurrentCultureIgnoreCase))).ToImmutableArray();
         }
 
         private void InitializeServices()
@@ -123,7 +123,7 @@ internal ImmutableArray<FunctionMetadata> LoadFunctionMetadata(bool forceRefresh
         {
             _functionMetadataMap.Clear();
 
-            ICollection<string> functionsWhiteList = _scriptOptions?.Value?.Functions;
+            ICollection<string> functionsAllowList = _scriptOptions?.Value?.Functions;
             _logger.FunctionMetadataManagerLoadingFunctionsMetadata();
 
             var immutableFunctionMetadata = _functionMetadataProvider.GetFunctionMetadata(_languageWorkerOptions.Value.WorkerConfigs, forceRefresh);
@@ -154,10 +154,10 @@ internal ImmutableArray<FunctionMetadata> LoadFunctionMetadata(bool forceRefresh
             }
             Errors = _functionErrors.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());
 
-            if (functionsWhiteList != null)
+            if (functionsAllowList != null)
             {
-                _logger.LogInformation($"A function whitelist has been specified, excluding all but the following functions: [{string.Join(", ", functionsWhiteList)}]");
-                Errors = _functionErrors.Where(kvp => functionsWhiteList.Any(functionName => functionName.Equals(kvp.Key, StringComparison.CurrentCultureIgnoreCase))).ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());
+                _logger.LogInformation($"A function allow list has been specified, excluding all but the following functions: [{string.Join(", ", functionsAllowList)}]");
+                Errors = _functionErrors.Where(kvp => functionsAllowList.Any(functionName => functionName.Equals(kvp.Key, StringComparison.CurrentCultureIgnoreCase))).ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());
             }
 
             return functionMetadataList.ToImmutableArray();
diff --git a/src/WebJobs.Script/Host/IFunctionMetadataManager.cs b/src/WebJobs.Script/Host/IFunctionMetadataManager.cs
@@ -10,7 +10,7 @@ public interface IFunctionMetadataManager
     {
         ImmutableDictionary<string, ImmutableArray<string>> Errors { get; }
 
-        ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh = false, bool applyWhitelist = true);
+        ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh = false, bool applyAllowlist = true);
 
         bool TryGetFunctionMetadata(string functionName, out FunctionMetadata functionMetadata, bool forceRefresh = false);
     }
diff --git a/src/WebJobs.Script/Workers/Rpc/RpcInitializationService.cs b/src/WebJobs.Script/Workers/Rpc/RpcInitializationService.cs
@@ -24,7 +24,7 @@ public class RpcInitializationService : IManagedHostedService
         private readonly string _workerRuntime;
         private readonly int _rpcServerShutdownTimeoutInMilliseconds;
 
-        private Dictionary<OSPlatform, List<string>> _hostingOSToWhitelistedRuntimes = new Dictionary<OSPlatform, List<string>>()
+        private Dictionary<OSPlatform, List<string>> _hostingOSToRuntimesAllowList = new Dictionary<OSPlatform, List<string>>()
         {
             {
                 OSPlatform.Windows,
@@ -41,12 +41,12 @@ public class RpcInitializationService : IManagedHostedService
         };
 
         // _webHostLevelWhitelistedRuntimes are started at webhost level when running in Azure and locally
-        private List<string> _webHostLevelWhitelistedRuntimes = new List<string>()
+        private List<string> _webHostLeveldRuntimesAllowList = new List<string>()
         {
             RpcWorkerConstants.JavaLanguageWorkerName
         };
 
-        private List<string> _placeholderPoolWhitelistedRuntimes = new List<string>()
+        private List<string> _placeholderPoolRuntimesAllowList = new List<string>()
         {
             RpcWorkerConstants.JavaLanguageWorkerName,
             RpcWorkerConstants.NodeLanguageWorkerName,
@@ -158,13 +158,13 @@ private Task InitializePlaceholderChannelsAsync()
 
         private Task InitializePlaceholderChannelsAsync(OSPlatform os)
         {
-            return Task.WhenAll(_hostingOSToWhitelistedRuntimes[os].Select(runtime =>
+            return Task.WhenAll(_hostingOSToRuntimesAllowList[os].Select(runtime =>
                 _webHostRpcWorkerChannelManager.InitializeChannelAsync(runtime)));
         }
 
         private Task InitializeWebHostRuntimeChannelsAsync()
         {
-            if (_webHostLevelWhitelistedRuntimes.Contains(_workerRuntime, StringComparer.OrdinalIgnoreCase))
+            if (_webHostLeveldRuntimesAllowList.Contains(_workerRuntime, StringComparer.OrdinalIgnoreCase))
             {
                 return _webHostRpcWorkerChannelManager.InitializeChannelAsync(_workerRuntime);
             }
@@ -191,10 +191,10 @@ internal bool ShouldStartAsPlaceholderPool()
             // We are in placeholder mode but a worker runtime IS set
             return _environment.IsPlaceholderModeEnabled()
                 && !string.IsNullOrEmpty(_workerRuntime)
-                && _placeholderPoolWhitelistedRuntimes.Contains(_workerRuntime, StringComparer.OrdinalIgnoreCase);
+                && _placeholderPoolRuntimesAllowList.Contains(_workerRuntime, StringComparer.OrdinalIgnoreCase);
         }
 
         // To help with unit tests
-        internal void AddSupportedWebHostLevelRuntime(string language) => _webHostLevelWhitelistedRuntimes.Add(language);
+        internal void AddSupportedWebHostLevelRuntime(string language) => _webHostLeveldRuntimesAllowList.Add(language);
     }
 }
diff --git a/test/WebJobs.Script.Tests.Integration/ApplicationInsights/ApplicationInsightsEndToEndTestsBase.cs b/test/WebJobs.Script.Tests.Integration/ApplicationInsights/ApplicationInsightsEndToEndTestsBase.cs
@@ -274,7 +274,7 @@ await TestHelpers.Await(() =>
 
             int idx = 0;
             ValidateTrace(traces[idx++], "2 functions loaded", LogCategories.Startup);
-            ValidateTrace(traces[idx++], "A function whitelist has been specified", LogCategories.Startup);
+            ValidateTrace(traces[idx++], "A function allow list has been specified", LogCategories.Startup);
             ValidateTrace(traces[idx++], "Found the following functions:\r\n", LogCategories.Startup);
             ValidateTrace(traces[idx++], "Generating 2 job function(s)", LogCategories.Startup);
             ValidateTrace(traces[idx++], "Host initialization: ConsecutiveErrors=0, StartupCount=1", LogCategories.Startup);
diff --git a/test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/CodelessEndToEndTests.cs b/test/WebJobs.Script.Tests.Integration/WebHostEndToEnd/CodelessEndToEndTests.cs
@@ -164,7 +164,7 @@ public async Task CodelessFunction_CanUse_MultipleProviders(string path, string
         [InlineData("NoFunction", "node", null, 0)]
         public async Task CodelessFunction_DoesNot_ListFunctions(string path, string workerRuntime, string allowedList, int listCount)
         {
-            // Note: admin/functions call includes all functions, regardless of the allowed list (whitelist)
+            // Note: admin/functions call includes all functions, regardless of the allowed list
             var sourceFunctionApp = Path.Combine(Environment.CurrentDirectory, "TestScripts", path);
             var settings = new Dictionary<string, string>()
             {
diff --git a/test/WebJobs.Script.Tests/Description/FunctionInvokerBaseTests.cs b/test/WebJobs.Script.Tests/Description/FunctionInvokerBaseTests.cs
@@ -279,7 +279,7 @@ public MockMetadataManager(ICollection<FunctionMetadata> functions)
             public ImmutableDictionary<string, ImmutableArray<string>> Errors =>
                 ImmutableDictionary<string, ImmutableArray<string>>.Empty;
 
-            public ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh = false, bool applyWhitelist = true)
+            public ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh = false, bool applyAllowlist = true)
             {
                 return _functions.ToImmutableArray();
             }

Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ internal IEnumerable<FunctionMetadata> GetFunctionsMetadata(bool includeProxies,`
`72`	`72`	`filterPredicate = m => m.IsProxy() \|\| !m.IsCodeless();`
`73`	`73`	`}`
`74`	`74`
`75`		`- return _functionMetadataManager.GetFunctionMetadata(forceRefresh, applyWhitelist: false).Where(filterPredicate);`
	`75`	`+ return _functionMetadataManager.GetFunctionMetadata(forceRefresh, applyAllowlist: false).Where(filterPredicate);`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -75,30 +75,30 @@ public bool TryGetFunctionMetadata(string functionName, out FunctionMetadata fun`
`75`	`75`	`/// Gets the function metadata array from all providers.`
`76`	`76`	`/// </summary>`
`77`	`77`	`/// <param name="forceRefresh">Forces reload from all providers.</param>`
`78`		`- /// <param name="applyWhitelist">Apply functions whitelist filter.</param>`
	`78`	`+ /// <param name="applyAllowList">Apply functions allow list filter.</param>`
`79`	`79`	`/// <returns> An Immmutable array of FunctionMetadata.</returns>`
`80`		`- public ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh, bool applyWhitelist = true)`
	`80`	`+ public ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh, bool applyAllowList = true)`
`81`	`81`	`{`
`82`	`82`	`if (forceRefresh \|\| _servicesReset \|\| _functionMetadataArray.IsDefaultOrEmpty)`
`83`	`83`	`{`
`84`	`84`	`_functionMetadataArray = LoadFunctionMetadata(forceRefresh);`
`85`		`- _logger.FunctionMetadataManagerFunctionsLoaded(ApplyWhitelist(_functionMetadataArray).Count());`
	`85`	`+ _logger.FunctionMetadataManagerFunctionsLoaded(ApplyAllowList(_functionMetadataArray).Count());`
`86`	`86`	`_servicesReset = false;`
`87`	`87`	`}`
`88`	`88`
`89`		`- return applyWhitelist ? ApplyWhitelist(_functionMetadataArray) : _functionMetadataArray;`
	`89`	`+ return applyAllowList ? ApplyAllowList(_functionMetadataArray) : _functionMetadataArray;`
`90`	`90`	`}`
`91`	`91`
`92`		`- private ImmutableArray<FunctionMetadata> ApplyWhitelist(ImmutableArray<FunctionMetadata> metadataList)`
	`92`	`+ private ImmutableArray<FunctionMetadata> ApplyAllowList(ImmutableArray<FunctionMetadata> metadataList)`
`93`	`93`	`{`
`94`		`- var whitelist = _scriptOptions.Value?.Functions;`
	`94`	`+ var allowList = _scriptOptions.Value?.Functions;`
`95`	`95`
`96`		`- if (whitelist == null \|\| metadataList.IsDefaultOrEmpty)`
	`96`	`+ if (allowList == null \|\| metadataList.IsDefaultOrEmpty)`
`97`	`97`	`{`
`98`	`98`	`return metadataList;`
`99`	`99`	`}`
`100`	`100`
`101`		`- return metadataList.Where(metadata => whitelist.Any(functionName => functionName.Equals(metadata.Name, StringComparison.CurrentCultureIgnoreCase))).ToImmutableArray();`
	`101`	`+ return metadataList.Where(metadata => allowList.Any(functionName => functionName.Equals(metadata.Name, StringComparison.CurrentCultureIgnoreCase))).ToImmutableArray();`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`private void InitializeServices()`
`@@ -123,7 +123,7 @@ internal ImmutableArray<FunctionMetadata> LoadFunctionMetadata(bool forceRefresh`
`123`	`123`	`{`
`124`	`124`	`_functionMetadataMap.Clear();`
`125`	`125`
`126`		`- ICollection<string> functionsWhiteList = _scriptOptions?.Value?.Functions;`
	`126`	`+ ICollection<string> functionsAllowList = _scriptOptions?.Value?.Functions;`
`127`	`127`	`_logger.FunctionMetadataManagerLoadingFunctionsMetadata();`
`128`	`128`
`129`	`129`	`var immutableFunctionMetadata = _functionMetadataProvider.GetFunctionMetadata(_languageWorkerOptions.Value.WorkerConfigs, forceRefresh);`
`@@ -154,10 +154,10 @@ internal ImmutableArray<FunctionMetadata> LoadFunctionMetadata(bool forceRefresh`
`154`	`154`	`}`
`155`	`155`	`Errors = _functionErrors.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());`
`156`	`156`
`157`		`- if (functionsWhiteList != null)`
	`157`	`+ if (functionsAllowList != null)`
`158`	`158`	`{`
`159`		`- _logger.LogInformation($"A function whitelist has been specified, excluding all but the following functions: [{string.Join(", ", functionsWhiteList)}]");`
`160`		`- Errors = _functionErrors.Where(kvp => functionsWhiteList.Any(functionName => functionName.Equals(kvp.Key, StringComparison.CurrentCultureIgnoreCase))).ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());`
	`159`	`+ _logger.LogInformation($"A function allow list has been specified, excluding all but the following functions: [{string.Join(", ", functionsAllowList)}]");`
	`160`	`+ Errors = _functionErrors.Where(kvp => functionsAllowList.Any(functionName => functionName.Equals(kvp.Key, StringComparison.CurrentCultureIgnoreCase))).ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray());`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`return functionMetadataList.ToImmutableArray();`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public interface IFunctionMetadataManager`
`10`	`10`	`{`
`11`	`11`	`ImmutableDictionary<string, ImmutableArray<string>> Errors { get; }`
`12`	`12`
`13`		`- ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh = false, bool applyWhitelist = true);`
	`13`	`+ ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh = false, bool applyAllowlist = true);`
`14`	`14`
`15`	`15`	`bool TryGetFunctionMetadata(string functionName, out FunctionMetadata functionMetadata, bool forceRefresh = false);`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public class RpcInitializationService : IManagedHostedService`
`24`	`24`	`private readonly string _workerRuntime;`
`25`	`25`	`private readonly int _rpcServerShutdownTimeoutInMilliseconds;`
`26`	`26`
`27`		`- private Dictionary<OSPlatform, List<string>> _hostingOSToWhitelistedRuntimes = new Dictionary<OSPlatform, List<string>>()`
	`27`	`+ private Dictionary<OSPlatform, List<string>> _hostingOSToRuntimesAllowList = new Dictionary<OSPlatform, List<string>>()`
`28`	`28`	`{`
`29`	`29`	`{`
`30`	`30`	`OSPlatform.Windows,`
`@@ -41,12 +41,12 @@ public class RpcInitializationService : IManagedHostedService`
`41`	`41`	`};`
`42`	`42`
`43`	`43`	`// _webHostLevelWhitelistedRuntimes are started at webhost level when running in Azure and locally`
`44`		`- private List<string> _webHostLevelWhitelistedRuntimes = new List<string>()`
	`44`	`+ private List<string> _webHostLeveldRuntimesAllowList = new List<string>()`
`45`	`45`	`{`
`46`	`46`	`RpcWorkerConstants.JavaLanguageWorkerName`
`47`	`47`	`};`
`48`	`48`
`49`		`- private List<string> _placeholderPoolWhitelistedRuntimes = new List<string>()`
	`49`	`+ private List<string> _placeholderPoolRuntimesAllowList = new List<string>()`
`50`	`50`	`{`
`51`	`51`	`RpcWorkerConstants.JavaLanguageWorkerName,`
`52`	`52`	`RpcWorkerConstants.NodeLanguageWorkerName,`
`@@ -158,13 +158,13 @@ private Task InitializePlaceholderChannelsAsync()`
`158`	`158`
`159`	`159`	`private Task InitializePlaceholderChannelsAsync(OSPlatform os)`
`160`	`160`	`{`
`161`		`- return Task.WhenAll(_hostingOSToWhitelistedRuntimes[os].Select(runtime =>`
	`161`	`+ return Task.WhenAll(_hostingOSToRuntimesAllowList[os].Select(runtime =>`
`162`	`162`	`_webHostRpcWorkerChannelManager.InitializeChannelAsync(runtime)));`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`private Task InitializeWebHostRuntimeChannelsAsync()`
`166`	`166`	`{`
`167`		`- if (_webHostLevelWhitelistedRuntimes.Contains(_workerRuntime, StringComparer.OrdinalIgnoreCase))`
	`167`	`+ if (_webHostLeveldRuntimesAllowList.Contains(_workerRuntime, StringComparer.OrdinalIgnoreCase))`
`168`	`168`	`{`
`169`	`169`	`return _webHostRpcWorkerChannelManager.InitializeChannelAsync(_workerRuntime);`
`170`	`170`	`}`
`@@ -191,10 +191,10 @@ internal bool ShouldStartAsPlaceholderPool()`
`191`	`191`	`// We are in placeholder mode but a worker runtime IS set`
`192`	`192`	`return _environment.IsPlaceholderModeEnabled()`
`193`	`193`	`&& !string.IsNullOrEmpty(_workerRuntime)`
`194`		`- && _placeholderPoolWhitelistedRuntimes.Contains(_workerRuntime, StringComparer.OrdinalIgnoreCase);`
	`194`	`+ && _placeholderPoolRuntimesAllowList.Contains(_workerRuntime, StringComparer.OrdinalIgnoreCase);`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`// To help with unit tests`
`198`		`- internal void AddSupportedWebHostLevelRuntime(string language) => _webHostLevelWhitelistedRuntimes.Add(language);`
	`198`	`+ internal void AddSupportedWebHostLevelRuntime(string language) => _webHostLeveldRuntimesAllowList.Add(language);`
`199`	`199`	`}`
`200`	`200`	`}`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ public async Task CodelessFunction_CanUse_MultipleProviders(string path, string`
`164`	`164`	`[InlineData("NoFunction", "node", null, 0)]`
`165`	`165`	`public async Task CodelessFunction_DoesNot_ListFunctions(string path, string workerRuntime, string allowedList, int listCount)`
`166`	`166`	`{`
`167`		`- // Note: admin/functions call includes all functions, regardless of the allowed list (whitelist)`
	`167`	`+ // Note: admin/functions call includes all functions, regardless of the allowed list`
`168`	`168`	`var sourceFunctionApp = Path.Combine(Environment.CurrentDirectory, "TestScripts", path);`
`169`	`169`	`var settings = new Dictionary<string, string>()`
`170`	`170`	`{`
Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ public MockMetadataManager(ICollection<FunctionMetadata> functions)`
`279`	`279`	`public ImmutableDictionary<string, ImmutableArray<string>> Errors =>`
`280`	`280`	`ImmutableDictionary<string, ImmutableArray<string>>.Empty;`
`281`	`281`
`282`		`- public ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh = false, bool applyWhitelist = true)`
	`282`	`+ public ImmutableArray<FunctionMetadata> GetFunctionMetadata(bool forceRefresh = false, bool applyAllowlist = true)`
`283`	`283`	`{`
`284`	`284`	`return _functions.ToImmutableArray();`
`285`	`285`	`}`