Implement mgmt resource

eng/Packages.Data.props

@@ -272,6 +272,7 @@
     <PackageReference Update="ApprovalTests" Version="3.0.22" />
     <PackageReference Update="ApprovalUtilities" Version="3.0.22" />
     <PackageReference Update="Azure.Core" Version="1.44.1" />
+    <PackageReference Update="Azure.ResourceManager" Version="1.13.0" />
     <PackageReference Update="Azure.Identity" Version="1.13.1" />
     <PackageReference Update="Azure.Messaging.EventGrid" Version="4.17.0" />
     <PackageReference Update="Azure.Messaging.EventHubs.Processor" Version="5.11.6" />

eng/packages/http-client-csharp/eng/scripts/Generate.ps1

@@ -19,7 +19,6 @@ if (-not $LaunchOnly) {
         $testProjectsLocalDir = Join-Path $packageRoot 'generator' 'TestProjects' 'Local'
 
         $unbrandedTypespecTestProject = Join-Path $testProjectsLocalDir "Basic-TypeSpec"
-        $unbrandedTypespecTestProject = $unbrandedTypespecTestProject
 
         Invoke (Get-TspCommand "$unbrandedTypespecTestProject/Basic-TypeSpec.tsp" $unbrandedTypespecTestProject -forceNewProject $ForceNewProject)
 
@@ -36,6 +35,28 @@ if (-not $LaunchOnly) {
             exit $LASTEXITCODE
         }
     }
+
+    if ($null -eq $filter -or $filter -eq "Mgmt-TypeSpec") {
+        Write-Host "Generating MgmtTypeSpec" -ForegroundColor Cyan
+        $testProjectsLocalDir = Join-Path $packageRoot 'generator' 'TestProjects' 'Local'
+
+        $mgmtTypespecTestProject = Join-Path $testProjectsLocalDir "Mgmt-TypeSpec"
+
+        Invoke (Get-TspCommand "$mgmtTypespecTestProject/main.tsp" $mgmtTypespecTestProject -forceNewProject $ForceNewProject)
+
+        # exit if the generation failed
+        if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+        }
+
+        Write-Host "Building MgmtTypeSpec" -ForegroundColor Cyan
+        Invoke "dotnet build $packageRoot/generator/TestProjects/Local/Mgmt-TypeSpec/src/MgmtTypeSpec.csproj"
+
+        # exit if the generation failed
+        if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+        }
+    }
 }
 
 $specsDirectory = "$packageRoot/node_modules/@typespec/http-specs"
@@ -175,13 +196,19 @@ if ($null -eq $filter) {
     $mgcExe = "`$(SolutionDir)/../dist/generator/Microsoft.Generator.CSharp.exe"
     $sampleExe = "`$(SolutionDir)/../generator/artifacts/bin/SamplePlugin/Debug/net8.0/Microsoft.Generator.CSharp.exe"
     $unbrandedSpec = "TestProjects/Local/Basic-TypeSpec"
+    $mgmtSpec = "TestProjects/Local/Mgmt-TypeSpec"
 
     $launchSettings = @{}
     $launchSettings.Add("profiles", @{})
     $launchSettings["profiles"].Add("Basic-TypeSpec", @{})
     $launchSettings["profiles"]["Basic-TypeSpec"].Add("commandLineArgs", "`$(SolutionDir)/../dist/generator/Microsoft.Generator.CSharp.dll `$(SolutionDir)/$unbrandedSpec -p AzureClientPlugin")
     $launchSettings["profiles"]["Basic-TypeSpec"].Add("commandName", "Executable")
     $launchSettings["profiles"]["Basic-TypeSpec"].Add("executablePath", "dotnet")
+
+    $launchSettings["profiles"].Add("Mgmt-TypeSpec", @{})
+    $launchSettings["profiles"]["Mgmt-TypeSpec"].Add("commandLineArgs", "`$(SolutionDir)/../dist/generator/Microsoft.Generator.CSharp.dll `$(SolutionDir)/$mgmtSpec -p AzureClientPlugin")
+    $launchSettings["profiles"]["Mgmt-TypeSpec"].Add("commandName", "Executable")
+    $launchSettings["profiles"]["Mgmt-TypeSpec"].Add("executablePath", "dotnet")
 
     foreach ($kvp in $spectorLaunchProjects.GetEnumerator()) {
         $launchSettings["profiles"].Add($kvp.Key, @{})

eng/packages/http-client-csharp/generator/Azure.Generator/src/AzureClientPlugin.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using Azure.ResourceManager;
 using Azure.Generator.Utilities;
 using Microsoft.CodeAnalysis;
 using Microsoft.TypeSpec.Generator;
@@ -30,6 +31,9 @@ public class AzureClientPlugin : ScmCodeModelPlugin
     public override AzureOutputLibrary OutputLibrary => _azureOutputLibrary ??= new();
 
     internal ResourceDetection ResourceDetection { get; } = new();
+    internal ParentDetection ParentDetection { get; } = new();
+    internal ScopeDetection ScopeDetection { get; } = new();
+    internal SingletonDetection SingletonDetection { get; } = new();
 
     /// <summary>
     /// The Azure client plugin to generate the Azure client SDK.
@@ -55,6 +59,8 @@ public override void Configure()
         AddVisitor(new NamespaceVisitor());
         if (IsAzureArm.Value)
         {
+            // Include Azure.ResourceManager
+            AddMetadataReference(MetadataReference.CreateFromFile(typeof(ArmClient).Assembly.Location));
             AddVisitor(new RestClientVisitor());
             AddVisitor(new ResourceVisitor());
         }

eng/packages/http-client-csharp/generator/Azure.Generator/src/AzureOutputLibrary.cs

@@ -5,26 +5,57 @@
 using Azure.Generator.Providers;
 using Azure.Generator.Utilities;
 using Microsoft.TypeSpec.Generator.ClientModel;
+using Microsoft.TypeSpec.Generator.ClientModel.Providers;
+using Microsoft.TypeSpec.Generator.Input;
 using Microsoft.TypeSpec.Generator.Providers;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Azure.Generator
 {
     /// <inheritdoc/>
     public class AzureOutputLibrary : ScmOutputLibrary
     {
-        // TODO: categorize clients into operationSets, which contains operations sharing the same Path
-        private Dictionary<string, OperationSet> _pathToOperationSetMap;
-        private Dictionary<string, HashSet<OperationSet>> _resourceDataBySpecNameMap;
+        //TODO: Move these to InputLibrary instead
+        private Dictionary<RequestPath, OperationSet> _pathToOperationSetMap;
+        private Dictionary<string, HashSet<OperationSet>> _specNameToOperationSetsMap;
+        private Dictionary<string, InputModelType> _inputTypeMap;
 
         /// <inheritdoc/>
         public AzureOutputLibrary()
         {
             _pathToOperationSetMap = CategorizeClients();
-            _resourceDataBySpecNameMap = EnsureResourceDataMap();
+            _specNameToOperationSetsMap = EnsureOperationsetMap();
+            _inputTypeMap = AzureClientPlugin.Instance.InputLibrary.InputNamespace.Models.OfType<InputModelType>().ToDictionary(model => model.Name);
         }
 
-        private Dictionary<string, HashSet<OperationSet>> EnsureResourceDataMap()
+        private MgmtLongRunningOperationProvider? _armOperation;
+        internal MgmtLongRunningOperationProvider ArmOperation => _armOperation ??= new MgmtLongRunningOperationProvider(false);
+
+        private MgmtLongRunningOperationProvider? _genericArmOperation;
+        internal MgmtLongRunningOperationProvider GenericArmOperation => _genericArmOperation ??= new MgmtLongRunningOperationProvider(true);
+
+        private IReadOnlyList<ResourceProvider> BuildResources(ModelSerializationExtensionsDefinition modelSerializationExtensions)
+        {
+            var result = new List<ResourceProvider>();
+            foreach ((var schemaName, var operationSets) in _specNameToOperationSetsMap)
+            {
+                var model = _inputTypeMap[schemaName];
+                var resourceData = AzureClientPlugin.Instance.TypeFactory.CreateModel(model)!;
+                foreach (var operationSet in operationSets)
+                {
+                    var requestPath = operationSet.RequestPath;
+                    var resourceType = ResourceDetection.GetResourceTypeFromPath(requestPath);
+                    var resource = new ResourceProvider(operationSet, schemaName, resourceData, resourceType, modelSerializationExtensions);
+                    AzureClientPlugin.Instance.AddTypeToKeep(resource.Name);
+                    result.Add(resource);
+                }
+            }
+            return result;
+        }
+
+        private Dictionary<string, HashSet<OperationSet>> EnsureOperationsetMap()
         {
             var result = new Dictionary<string, HashSet<OperationSet>>();
             foreach (var operationSet in _pathToOperationSetMap.Values)
@@ -44,16 +75,14 @@ private Dictionary<string, HashSet<OperationSet>> EnsureResourceDataMap()
             return result;
         }
 
-        private Dictionary<string, OperationSet> CategorizeClients()
+        private Dictionary<RequestPath, OperationSet> CategorizeClients()
         {
-            var result = new Dictionary<string, OperationSet>();
+            var result = new Dictionary<RequestPath, OperationSet>();
             foreach (var inputClient in AzureClientPlugin.Instance.InputLibrary.InputNamespace.Clients)
             {
-                var requestPathList = new HashSet<string>();
                 foreach (var operation in inputClient.Operations)
                 {
                     var path = operation.GetHttpPath();
-                    requestPathList.Add(path);
                     if (result.TryGetValue(path, out var operationSet))
                     {
                         operationSet.Add(operation);
@@ -75,22 +104,21 @@ private Dictionary<string, OperationSet> CategorizeClients()
         }
 
         /// <inheritdoc/>
-        // TODO: generate resources and collections
+        // TODO: generate collections
         protected override TypeProvider[] BuildTypeProviders()
         {
+            var baseProviders = base.BuildTypeProviders();
+            ModelSerializationExtensionsDefinition modelSerializationExtensions = (ModelSerializationExtensionsDefinition)baseProviders.Single(p => p is ModelSerializationExtensionsDefinition);
             if (AzureClientPlugin.Instance.IsAzureArm.Value == true)
             {
-                var armOperation = new MgmtLongRunningOperationProvider(false);
-                var genericArmOperation = new MgmtLongRunningOperationProvider(true);
-
-                // TODO: remove them once they are referenced in Resource operation implementation
-                AzureClientPlugin.Instance.AddTypeToKeep(armOperation.Name);
-                AzureClientPlugin.Instance.AddTypeToKeep(genericArmOperation.Name);
-                return [.. base.BuildTypeProviders(), new RequestContextExtensionsDefinition(), armOperation, genericArmOperation];
+                var resources = BuildResources(modelSerializationExtensions);
+                return [.. base.BuildTypeProviders(), new RequestContextExtensionsDefinition(), ArmOperation, GenericArmOperation, .. resources, .. resources.Select(r => r.Source)];
             }
             return [.. base.BuildTypeProviders(), new RequestContextExtensionsDefinition()];
         }
 
-        internal bool IsResource(string name) => _resourceDataBySpecNameMap.ContainsKey(name);
+        internal bool IsResource(string name) => _specNameToOperationSetsMap.ContainsKey(name);
+
+        internal Lazy<IEnumerable<OperationSet>> ResourceOperationSets => new(() => _specNameToOperationSetsMap.Values.SelectMany(x => x));
     }
 }

eng/packages/http-client-csharp/generator/Azure.Generator/src/Mgmt/Models/OperationSet.cs

@@ -17,12 +17,12 @@ namespace Azure.Generator.Mgmt.Models
     /// </summary>
     internal class OperationSet : IReadOnlyCollection<InputOperation>, IEquatable<OperationSet>
     {
-        private readonly InputClient? _inputClient;
-
         /// <summary>
         /// The raw request path of string of the operations in this <see cref="OperationSet"/>
         /// </summary>
-        public string RequestPath { get; }
+        public RequestPath RequestPath { get; }
+
+        public InputClient InputClient { get; }
 
         /// <summary>
         /// The operation set
@@ -31,9 +31,9 @@ internal class OperationSet : IReadOnlyCollection<InputOperation>, IEquatable<Op
 
         public int Count => _operations.Count;
 
-        public OperationSet(string requestPath, InputClient? inputClient)
+        public OperationSet(RequestPath requestPath, InputClient inputClient)
         {
-            _inputClient = inputClient;
+            InputClient = inputClient;
             RequestPath = requestPath;
             _operations = new HashSet<InputOperation>();
         }
@@ -46,7 +46,7 @@ public OperationSet(string requestPath, InputClient? inputClient)
         public void Add(InputOperation operation)
         {
             var path = operation.GetHttpPath();
-            if (path != RequestPath)
+            if (!path.Equals(RequestPath))
                 throw new InvalidOperationException($"Cannot add operation with path {path} to OperationSet with path {RequestPath}");
             _operations.Add(operation);
         }

eng/packages/http-client-csharp/generator/Azure.Generator/src/Mgmt/Models/RequestPath.cs

@@ -0,0 +1,157 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace Azure.Generator.Mgmt.Models
+{
+    internal class RequestPath : IEquatable<RequestPath>, IReadOnlyList<string>
+    {
+        private const string ProviderPath = "/subscriptions/{subscriptionId}/providers/{resourceProviderNamespace}";
+        private const string FeaturePath = "/subscriptions/{subscriptionId}/providers/Microsoft.Features/providers/{resourceProviderNamespace}/features";
+
+        public const string ManagementGroupScopePrefix = "/providers/Microsoft.Management/managementGroups";
+        public const string ResourceGroupScopePrefix = "/subscriptions/{subscriptionId}/resourceGroups";
+        public const string SubscriptionScopePrefix = "/subscriptions";
+        public const string TenantScopePrefix = "/tenants";
+        public const string Providers = "/providers";
+
+        public static readonly RequestPath ManagementGroup = new("/providers/Microsoft.Management/managementGroups/{managementGroupId}");
+        public static readonly RequestPath ResourceGroup = new("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}");
+        public static readonly RequestPath Subscription = new("/subscriptions/{subscriptionId}");
+        public static readonly RequestPath Tenant = new(string.Empty);
+
+        private string _path;
+        private IReadOnlyList<string> _segments;
+
+        public RequestPath(string path)
+        {
+            _path = path;
+            _segments = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
+            IndexOfLastProviders = _path.LastIndexOf(Providers);
+        }
+
+        public RequestPath(IEnumerable<string> segments)
+        {
+            _segments = segments.ToArray();
+            _path = string.Join("/", _segments);
+        }
+
+        public int Count => _segments.Count;
+
+        public string SerializedPath => _path;
+
+        public int IndexOfLastProviders { get; }
+
+        public string this[int index] => _segments[index];
+
+        /// <summary>
+        /// Check if this <see cref="RequestPath"/> is a prefix path of the other request path.
+        /// Note that this.IsAncestorOf(this) will return false which indicates that this method is testing the "proper ancestor" like a proper subset.
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        public bool IsAncestorOf(RequestPath other)
+        {
+            // To be the parent of other, you must at least be shorter than other.
+            if (other.Count <= Count)
+                return false;
+            for (int i = 0; i < Count; i++)
+            {
+                // we need the segment to be identical when strict is true (which is the default value)
+                // when strict is false, we also need the segment to be identical if it is constant.
+                // but if it is a reference, we only require they have the same type, do not require they have the same variable name.
+                // This case happens a lot during the management group parent detection - different RP calls this different things
+                if (!this[i].Equals(other[i]))
+                    return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Trim this from the other and return the <see cref="RequestPath"/>that remain.
+        /// The result is "other - this" by removing this as a prefix of other.
+        /// If this == other, return empty request path
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        /// <exception cref="InvalidOperationException">if this.IsAncestorOf(other) is false</exception>
+        public RequestPath TrimAncestorFrom(RequestPath other)
+        {
+            if (TryTrimAncestorFrom(other, out var diff))
+                return diff;
+
+            throw new InvalidOperationException($"Request path {this} is not parent of {other}");
+        }
+
+        private bool TryTrimAncestorFrom(RequestPath other, [MaybeNullWhen(false)] out RequestPath diff)
+        {
+            diff = default;
+            if (this == other)
+            {
+                diff = Tenant;
+                return true;
+            }
+            if (IsAncestorOf(other))
+            {
+                diff = new RequestPath(string.Join("", other._segments.Skip(Count)));
+                return true;
+            }
+            // Handle the special case of trim provider from feature
+            else if (_path == ProviderPath && other._path.StartsWith(FeaturePath))
+            {
+                diff = new RequestPath(string.Join("", other._segments.Skip(Count + 2)));
+                return true;
+            }
+            return false;
+        }
+
+        public bool Equals(RequestPath? other)
+        {
+            if (Count != other?.Count)
+                return false;
+            for (int i = 0; i < Count; i++)
+            {
+                if (!this[i].Equals(other[i]))
+                    return false;
+            }
+            return true;
+        }
+
+        public override bool Equals(object? obj) => obj is RequestPath other && Equals(other);
+
+        public override int GetHashCode() => _path.GetHashCode();
+
+        public override string ToString() => _path;
+
+        public IEnumerator<String> GetEnumerator() => _segments.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => _segments.GetEnumerator();
+
+        public static bool operator ==(RequestPath left, RequestPath right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(RequestPath left, RequestPath right)
+        {
+            return !(left == right);
+        }
+
+        public static implicit operator string(RequestPath requestPath)
+        {
+            return requestPath._path;
+        }
+
+        public static bool IsSegmentConstant(string segment)
+        {
+            var trimmed = segment.TrimStart('{').TrimEnd('}');
+            var isScope = trimmed == "scope";
+            return !isScope && !segment.StartsWith('{');
+        }
+    }
+}