Support Microsoft Feature Flag schema feature flag schema v1.1.0 by default

src/Microsoft.FeatureManagement/ConfigurationFeatureDefinitionProvider.cs

@@ -22,13 +22,13 @@ public sealed class ConfigurationFeatureDefinitionProvider : IFeatureDefinitionP
         // IFeatureDefinitionProviderCacheable interface is only used to mark this provider as cacheable. This allows our test suite's
         // provider to be marked for caching as well.
 
-        private const string FeatureFiltersSectionName = "EnabledFor";
-        private const string RequirementTypeKeyword = "RequirementType";
-        private const string FeatureManagementSectionName = "FeatureManagement";
         private readonly IConfiguration _configuration;
         private readonly ConcurrentDictionary<string, FeatureDefinition> _definitions;
         private IDisposable _changeSubscription;
         private int _stale = 0;
+        private long _initialized = 0;
+        private bool _microsoftFeatureFlagSchemaEnabled;
+        private readonly object _lock = new object();
 
         /// <summary>
         /// Creates a configuration feature definition provider.
@@ -81,6 +81,8 @@ public Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName)
                 throw new ArgumentException($"The value '{ConfigurationPath.KeyDelimiter}' is not allowed in the feature name.", nameof(featureName));
             }
 
+            EnsureInit();
+
             if (Interlocked.Exchange(ref _stale, 0) != 0)
             {
                 _definitions.Clear();
@@ -104,6 +106,8 @@ public Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName)
         public async IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync()
 #pragma warning restore CS1998
         {
+            EnsureInit();
+
             if (Interlocked.Exchange(ref _stale, 0) != 0)
             {
                 _definitions.Clear();
@@ -113,16 +117,55 @@ public async IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync()
             // Iterate over all features registered in the system at initial invocation time
             foreach (IConfigurationSection featureSection in GetFeatureDefinitionSections())
             {
+                string featureName = GetFeatureName(featureSection);
+
+                if (string.IsNullOrEmpty(featureName))
+                {
+                    continue;
+                }
+
                 //
                 // Underlying IConfigurationSection data is dynamic so latest feature definitions are returned
-                yield return  _definitions.GetOrAdd(featureSection.Key, (_) => ReadFeatureDefinition(featureSection));
+                yield return  _definitions.GetOrAdd(featureName, (_) => ReadFeatureDefinition(featureSection));
+            }
+        }
+
+        private void EnsureInit()
+        {
+            if (_initialized == 0)
+            {
+                IConfiguration featureManagementConfigurationSection = _configuration
+                    .GetChildren()
+                    .FirstOrDefault(section =>
+                        string.Equals(
+                            section.Key,
+                            ConfigurationFields.FeatureManagementSectionName,
+                            StringComparison.OrdinalIgnoreCase));
+
+                if (featureManagementConfigurationSection == null && RootConfigurationFallbackEnabled)
+                {
+                    featureManagementConfigurationSection = _configuration;
+                }
+
+                bool hasMicrosoftFeatureFlagSchema = featureManagementConfigurationSection != null && 
+                    HasMicrosoftFeatureFlagSchema(featureManagementConfigurationSection);
+
+                lock (_lock)
+                {
+                    if (Interlocked.Read(ref _initialized) == 0)
+                    {
+                        _microsoftFeatureFlagSchemaEnabled = hasMicrosoftFeatureFlagSchema;
+
+                        Interlocked.Exchange(ref _initialized, 1);
+                    }
+                }
             }
         }
 
         private FeatureDefinition ReadFeatureDefinition(string featureName)
         {
             IConfigurationSection configuration = GetFeatureDefinitionSections()
-                                                    .FirstOrDefault(section => section.Key.Equals(featureName, StringComparison.OrdinalIgnoreCase));
+                .FirstOrDefault(section => string.Equals(GetFeatureName(section), featureName, StringComparison.OrdinalIgnoreCase));
 
             if (configuration == null)
             {
@@ -133,6 +176,16 @@ private FeatureDefinition ReadFeatureDefinition(string featureName)
         }
 
         private FeatureDefinition ReadFeatureDefinition(IConfigurationSection configurationSection)
+        {
+            if (_microsoftFeatureFlagSchemaEnabled)
+            {
+                return ParseMicrosoftFeatureDefinition(configurationSection);
+            }
+
+            return ParseFeatureDefinition(configurationSection);
+        }
+
+        private FeatureDefinition ParseFeatureDefinition(IConfigurationSection configurationSection)
         {
             /*
 
@@ -167,15 +220,17 @@ We support
 
             */
 
-            RequirementType requirementType = RequirementType.Any;
+            string featureName = GetFeatureName(configurationSection);
 
             var enabledFor = new List<FeatureFilterConfiguration>();
 
+            RequirementType requirementType = RequirementType.Any;
+
             string val = configurationSection.Value; // configuration[$"{featureName}"];
 
             if (string.IsNullOrEmpty(val))
             {
-                val = configurationSection[FeatureFiltersSectionName];
+                val = configurationSection[ConfigurationFields.FeatureFiltersSectionName];
             }
 
             if (!string.IsNullOrEmpty(val) && bool.TryParse(val, out bool result) && result)
@@ -193,64 +248,215 @@ We support
             }
             else
             {
-                string rawRequirementType = configurationSection[RequirementTypeKeyword];
+                string rawRequirementType = configurationSection[ConfigurationFields.RequirementType];
 
                 //
                 // If requirement type is specified, parse it and set the requirementType variable
                 if (!string.IsNullOrEmpty(rawRequirementType) && !Enum.TryParse(rawRequirementType, ignoreCase: true, out requirementType))
                 {
                     throw new FeatureManagementException(
-                        FeatureManagementError.InvalidConfigurationSetting, 
-                        $"Invalid requirement type '{rawRequirementType}' for feature '{configurationSection.Key}'.");
+                        FeatureManagementError.InvalidConfigurationSetting,
+                        $"Invalid value '{rawRequirementType}' for field '{ConfigurationFields.RequirementType}' of feature '{featureName}'.");
                 }
 
-                IEnumerable<IConfigurationSection> filterSections = configurationSection.GetSection(FeatureFiltersSectionName).GetChildren();
+                IEnumerable<IConfigurationSection> filterSections = configurationSection.GetSection(ConfigurationFields.FeatureFiltersSectionName).GetChildren();
 
                 foreach (IConfigurationSection section in filterSections)
                 {
                     //
                     // Arrays in json such as "myKey": [ "some", "values" ]
                     // Are accessed through the configuration system by using the array index as the property name, e.g. "myKey": { "0": "some", "1": "values" }
-                    if (int.TryParse(section.Key, out int i) && !string.IsNullOrEmpty(section[nameof(FeatureFilterConfiguration.Name)]))
+                    if (int.TryParse(section.Key, out int _) && !string.IsNullOrEmpty(section[ConfigurationFields.NameKeyword]))
                     {
                         enabledFor.Add(new FeatureFilterConfiguration()
                         {
-                            Name = section[nameof(FeatureFilterConfiguration.Name)],
-                            Parameters = new ConfigurationWrapper(section.GetSection(nameof(FeatureFilterConfiguration.Parameters)))
+                            Name = section[ConfigurationFields.NameKeyword],
+                            Parameters = new ConfigurationWrapper(section.GetSection(ConfigurationFields.FeatureFilterConfigurationParameters))
                         });
                     }
                 }
             }
 
             return new FeatureDefinition()
             {
-                Name = configurationSection.Key,
+                Name = featureName,
                 EnabledFor = enabledFor,
                 RequirementType = requirementType
             };
         }
 
-        private IEnumerable<IConfigurationSection> GetFeatureDefinitionSections()
+        private FeatureDefinition ParseMicrosoftFeatureDefinition(IConfigurationSection configurationSection)
         {
+            /*
+
+            If Microsoft feature flag schema is enabled, we support
+
+            FeatureFlags: [
+              {
+                id: "myFeature",
+                enabled: true,
+                conditions: {
+                  client_filters: ["myFeatureFilter1", "myFeatureFilter2"],
+                  requirement_type: "All",
+                }
+              },
+              {
+                id: "myAlwaysEnabledFeature",
+                enabled: true,
+                conditions: {
+                  client_filters: [],
+                }
+              },
+              {
+                id: "myAlwaysDisabledFeature",
+                enabled: false,
+              }
+            ]
+
+            */
+
+            string featureName = GetFeatureName(configurationSection);
+
+            var enabledFor = new List<FeatureFilterConfiguration>();
+
+            RequirementType requirementType = RequirementType.Any;
+
+            IConfigurationSection conditions = configurationSection.GetSection(MicrosoftFeatureFlagFields.Conditions);
+
+            string rawRequirementType = conditions[MicrosoftFeatureFlagFields.RequirementType];
+
             //
-            // Look for feature definitions under the "FeatureManagement" section
-            IConfigurationSection featureManagementConfigurationSection = _configuration.GetSection(FeatureManagementSectionName);
+            // If requirement type is specified, parse it and set the requirementType variable
+            if (!string.IsNullOrEmpty(rawRequirementType) && !Enum.TryParse(rawRequirementType, ignoreCase: true, out requirementType))
+            {
+                throw new FeatureManagementException(
+                    FeatureManagementError.InvalidConfigurationSetting,
+                    $"Invalid value '{rawRequirementType}' for field '{MicrosoftFeatureFlagFields.RequirementType}' of feature '{featureName}'.");
+            }
+
+            string rawEnabled = configurationSection[MicrosoftFeatureFlagFields.Enabled];
 
-            if (featureManagementConfigurationSection.Exists())
+            bool enabled = false;
+
+            if (!string.IsNullOrEmpty(rawEnabled) && !bool.TryParse(rawEnabled, out enabled))
             {
-                return featureManagementConfigurationSection.GetChildren();
+                throw new FeatureManagementException(
+                    FeatureManagementError.InvalidConfigurationSetting,
+                    $"Invalid value '{rawEnabled}' for field '{MicrosoftFeatureFlagFields.Enabled}' of feature '{featureName}'.");
             }
 
-            //
-            // There is no "FeatureManagement" section in the configuration
-            if (RootConfigurationFallbackEnabled)
+            if (enabled)
             {
-                return _configuration.GetChildren();
+                IEnumerable<IConfigurationSection> filterSections = conditions.GetSection(MicrosoftFeatureFlagFields.ClientFilters).GetChildren();
+
+                if (filterSections.Any())
+                {
+                    foreach (IConfigurationSection section in filterSections)
+                    {
+                        //
+                        // Arrays in json such as "myKey": [ "some", "values" ]
+                        // Are accessed through the configuration system by using the array index as the property name, e.g. "myKey": { "0": "some", "1": "values" }
+                        if (int.TryParse(section.Key, out int _) && !string.IsNullOrEmpty(section[MicrosoftFeatureFlagFields.Name]))
+                        {
+                            enabledFor.Add(new FeatureFilterConfiguration()
+                            {
+                                Name = section[MicrosoftFeatureFlagFields.Name],
+                                Parameters = new ConfigurationWrapper(section.GetSection(MicrosoftFeatureFlagFields.Parameters))
+                            });
+                        }
+                    }
+                }
+                else
+                {
+                    enabledFor.Add(new FeatureFilterConfiguration
+                    {
+                        Name = "AlwaysOn"
+                    });
+                }
             }
 
-            Logger?.LogDebug($"No configuration section named '{FeatureManagementSectionName}' was found.");
+            return new FeatureDefinition()
+            {
+                Name = featureName,
+                EnabledFor = enabledFor,
+                RequirementType = requirementType
+            };
+        }
+
+        private string GetFeatureName(IConfigurationSection section)
+        {
+            if (_microsoftFeatureFlagSchemaEnabled)
+            {
+                return section[MicrosoftFeatureFlagFields.Id];
+            }
+
+            return section.Key;
+        }
+
+        private IEnumerable<IConfigurationSection> GetFeatureDefinitionSections()
+        {
+            if (!_configuration.GetChildren().Any())
+            {
+                Logger?.LogDebug($"Configuration is empty.");
+
+                return Enumerable.Empty<IConfigurationSection>();
+            }
+
+            IConfiguration featureManagementConfigurationSection = _configuration
+                    .GetChildren()
+                    .FirstOrDefault(section =>
+                        string.Equals(
+                            section.Key,
+                            ConfigurationFields.FeatureManagementSectionName,
+                            StringComparison.OrdinalIgnoreCase));
+
+            if (featureManagementConfigurationSection == null)
+            {
+                if (RootConfigurationFallbackEnabled)
+                {
+                    featureManagementConfigurationSection = _configuration;
+                }
+                else
+                {
+                    Logger?.LogDebug($"No configuration section named '{ConfigurationFields.FeatureManagementSectionName}' was found.");
+
+                    return Enumerable.Empty<IConfigurationSection>();
+                }
+            }
+
+            if (_microsoftFeatureFlagSchemaEnabled)
+            {
+                IConfigurationSection featureFlagsSection = featureManagementConfigurationSection.GetSection(MicrosoftFeatureFlagFields.FeatureFlagsSectionName);
+
+                return featureFlagsSection.GetChildren();
+            }
+
+            return featureManagementConfigurationSection.GetChildren();
+        }
+
+        private static bool HasMicrosoftFeatureFlagSchema(IConfiguration featureManagementConfiguration)
+        {
+            IConfigurationSection featureFlagsConfigurationSection = featureManagementConfiguration
+              .GetChildren()
+              .FirstOrDefault(section =>
+                  string.Equals(
+                      section.Key,
+                      MicrosoftFeatureFlagFields.FeatureFlagsSectionName,
+                      StringComparison.OrdinalIgnoreCase));
+
+            if (featureFlagsConfigurationSection != null)
+            {
+                if (!string.IsNullOrEmpty(featureFlagsConfigurationSection.Value))
+                {
+                    return false;
+                }
+
+                IEnumerable<IConfigurationSection> featureFlagsChildren = featureFlagsConfigurationSection.GetChildren();
+
+                return featureFlagsChildren.Any() && featureFlagsChildren.All(section => int.TryParse(section.Key, out int _));
+            }
 
-            return Enumerable.Empty<IConfigurationSection>();
+            return false;
         }
     }
 }

src/Microsoft.FeatureManagement/ConfigurationFields.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+
+namespace Microsoft.FeatureManagement
+{
+    internal static class ConfigurationFields
+    {
+        // Enum keywords
+        public const string RequirementType = "RequirementType";
+
+        // Feature filters keywords
+        public const string FeatureFiltersSectionName = "EnabledFor";
+        public const string FeatureFilterConfigurationParameters = "Parameters";
+
+        // Other keywords
+        public const string NameKeyword = "Name";
+        public const string FeatureManagementSectionName = "FeatureManagement";
+    }
+}