Use ARM Graph to list resources (#4548)

* WIP to use ARM graph for listing

* Build fixes

* Update version for testing

* Make changes to get site asynchronously

* Simplfy the resolver code

Author: nturinski

package-lock.json

@@ -2,7 +2,7 @@
     "name": "vscode-azurefunctions",
     "displayName": "Azure Functions",
     "description": "%azureFunctions.description%",
-    "version": "1.17.3",
+    "version": "1.17.4-alpha",
     "publisher": "ms-azuretools",
     "icon": "resources/azure-functions.png",
     "aiKey": "0c6ae279ed8443289764825290e4f9e2-1a736e7c-1324-4338-be46-fc2a58ae4d14-7255",
@@ -1473,6 +1473,7 @@
         "@azure/arm-appservice": "^15.0.0",
         "@azure/arm-cosmosdb": "^15.0.0",
         "@azure/arm-eventhub": "^5.1.0",
+        "@azure/arm-resourcegraph": "^5.0.0-beta.3",
         "@azure/arm-resources-profile-2020-09-01-hybrid": "^2.1.0",
         "@azure/arm-servicebus": "^5.0.0",
         "@azure/arm-sql": "^9.1.0",

package.json

@@ -1,53 +1,102 @@
-import { type Site } from "@azure/arm-appservice";
-import { getResourceGroupFromId, uiUtils } from "@microsoft/vscode-azext-azureutils";
-import { callWithTelemetryAndErrorHandling, nonNullProp, nonNullValue, nonNullValueAndProp, type IActionContext, type ISubscriptionContext } from "@microsoft/vscode-azext-utils";
+import { type ResourceGraphClient } from "@azure/arm-resourcegraph";
+import { createWebSiteClient } from "@microsoft/vscode-azext-azureappservice";
+import { callWithTelemetryAndErrorHandling, nonNullProp, nonNullValueAndProp, type IActionContext, type ISubscriptionContext } from "@microsoft/vscode-azext-utils";
 import { type AppResource, type AppResourceResolver } from "@microsoft/vscode-azext-utils/hostapi";
 import { ResolvedFunctionAppResource } from "./tree/ResolvedFunctionAppResource";
 import { ResolvedContainerizedFunctionAppResource } from "./tree/containerizedFunctionApp/ResolvedContainerizedFunctionAppResource";
-import { createWebSiteClient } from "./utils/azureClients";
+import { createResourceGraphClient } from "./utils/azureClients";
 
-// TODO: this is temporary until the new SDK with api-version=2023-12-01 is available
-type Site20231201 = Site & { isFlex?: boolean };
+export type FunctionAppModel = {
+    pricingTier: string,
+    id: string,
+    kind: string,
+    name: string,
+    resourceGroup: string,
+    status: string,
+    location: string
+}
+
+type FunctionQueryModel = {
+    properties: {
+        sku: string,
+        state: string
+    },
+    location: string,
+    id: string,
+    kind: string,
+    name: string,
+    resourceGroup: string
+}
 export class FunctionAppResolver implements AppResourceResolver {
+    private loaded: boolean = false;
     private siteCacheLastUpdated = 0;
-    private siteCache: Map<string, Site20231201> = new Map<string, Site20231201>();
+    private siteCache: Map<string, FunctionAppModel> = new Map<string, FunctionAppModel>();
     private listFunctionAppsTask: Promise<void> | undefined;
 
     public async resolveResource(subContext: ISubscriptionContext, resource: AppResource): Promise<ResolvedFunctionAppResource | ResolvedContainerizedFunctionAppResource | undefined> {
         return await callWithTelemetryAndErrorHandling('resolveResource', async (context: IActionContext) => {
-            const client = await createWebSiteClient({ ...context, ...subContext });
-
             if (this.siteCacheLastUpdated < Date.now() - 1000 * 3) {
                 this.siteCacheLastUpdated = Date.now();
-                this.listFunctionAppsTask = new Promise((resolve, reject) => {
-                    this.siteCache.clear();
-                    uiUtils.listAllIterator(client.webApps.list()).then((sites) => {
-                        for (const site of sites) {
-                            this.siteCache.set(nonNullProp(site, 'id').toLowerCase(), site);
-                        }
-                        resolve();
-                    })
-                        .catch((reason) => {
-                            reject(reason);
+                const graphClient = await createResourceGraphClient({ ...context, ...subContext });
+                async function fetchAllApps(graphClient: ResourceGraphClient, subContext: ISubscriptionContext, resolver: FunctionAppResolver): Promise<void> {
+                    resolver.loaded = false;
+                    resolver.siteCache.clear(); // clear the cache before fetching new data
+                    const query = `resources | where type == 'microsoft.web/sites' and kind contains 'functionapp' and kind !contains 'workflowapp'`;
+
+                    async function fetchApps(skipToken?: string): Promise<void> {
+                        const response = await graphClient.resources({
+                            query,
+                            subscriptions: [subContext.subscriptionId],
+                            options: {
+                                skipToken,
+                            }
+                        });
+
+                        const record = response.data as Record<string, FunctionQueryModel>;
+                        Object.values(record).forEach(data => {
+                            const dataModel: FunctionAppModel = {
+                                pricingTier: data.properties.sku,
+                                id: data.id,
+                                kind: data.kind,
+                                name: data.name,
+                                resourceGroup: data.resourceGroup,
+                                status: data.properties.state,
+                                location: data.location
+                            }
+                            resolver.siteCache.set(dataModel.id.toLowerCase(), dataModel);
                         });
-                });
+
+                        const nextSkipToken = response?.skipToken;
+                        if (nextSkipToken) {
+                            await fetchApps(nextSkipToken);  // recurse to next page
+                        } else {
+                            resolver.loaded = true; // mark as loaded when all pages are fetched
+                            return;
+                        }
+                    }
+
+                    return await fetchApps();  // start with no skipToken
+                }
+
+                this.listFunctionAppsTask = fetchAllApps(graphClient, subContext, this);
             }
-            await this.listFunctionAppsTask;
-
-            let site = this.siteCache.get(nonNullProp(resource, 'id').toLowerCase());
-            // check for required properties that sometime don't exist in the LIST operation
-            if (!site || !site.defaultHostName) {
-                // if this required property doesn't exist, try getting the full site payload
-                site = await client.webApps.get(getResourceGroupFromId(resource.id), resource.name);
-                this.siteCache.set(resource.id.toLowerCase(), site);
+
+            while (!this.loaded) {
+                // wait for the data to be loaded
+                await this.listFunctionAppsTask;
             }
 
+            const site = this.siteCache.get(nonNullProp(resource, 'id').toLowerCase());
             if (nonNullValueAndProp(site, 'kind') === 'functionapp,linux,container,azurecontainerapps') {
+                const client = await createWebSiteClient({ ...context, ...subContext });
                 const fullSite = await client.webApps.get(nonNullValueAndProp(site, 'resourceGroup'), nonNullValueAndProp(site, 'name'));
                 return ResolvedContainerizedFunctionAppResource.createResolvedFunctionAppResource(context, subContext, fullSite);
             }
+            if (site) {
+                return new ResolvedFunctionAppResource(subContext, site);
+            }
 
-            return ResolvedFunctionAppResource.createResolvedFunctionAppResource(context, subContext, nonNullValue(site));
+            return undefined;
         });
     }
 

src/FunctionAppResolver.ts

@@ -14,5 +14,5 @@ export async function browseWebsite(context: IActionContext, node?: SlotTreeItem
         node = await pickAppResource(context);
     }
 
-    await openUrl(nonNullValueAndProp(node.site, 'defaultHostUrl'));
+    await openUrl(nonNullValueAndProp(await node.getSite(context), 'defaultHostUrl'));
 }

src/commands/browseWebsite.ts

@@ -13,7 +13,7 @@ export async function configureDeploymentSource(context: IActionContext, node?:
         node = await pickFunctionApp(context);
     }
 
-    const updatedScmType: string | undefined = await editScmType(context, node.site, node.subscription);
+    const updatedScmType: string | undefined = await editScmType(context, (await node.getSite(context)), node.subscription);
     if (updatedScmType !== undefined) {
         context.telemetry.properties.updatedScmType = updatedScmType;
     }

src/commands/configureDeploymentSource.ts

@@ -369,9 +369,10 @@ export async function getEolWarningMessages(context: ISubscriptionActionContext,
 
 export async function showEolWarningIfNecessary(context: ISubscriptionActionContext, parent: AzExtParentTreeItem, client?: IAppSettingsClient) {
     if (isResolvedFunctionApp(parent)) {
-        client = client ?? await parent.site.createClient(context);
+        const site = await parent.getSite(context);
+        client = client ?? await site.createClient(context);
         const eolWarningMessage = await getEolWarningMessages(context, {
-            site: parent.site.rawSite,
+            site: site.rawSite,
             isLinux: client.isLinux,
             isFlex: parent.isFlex,
             client

src/commands/createFunctionApp/stacks/getStackPicks.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { type Site, type SiteConfigResource, type StringDictionary } from '@azure/arm-appservice';
-import { getDeployFsPath, getDeployNode, deploy as innerDeploy, showDeployConfirmation, type IDeployContext, type IDeployPaths } from '@microsoft/vscode-azext-azureappservice';
+import { getDeployFsPath, getDeployNode, deploy as innerDeploy, showDeployConfirmation, type IDeployContext, type IDeployPaths, type ParsedSite } from '@microsoft/vscode-azext-azureappservice';
 import { DialogResponses, type ExecuteActivityContext, type IActionContext, type ISubscriptionActionContext } from '@microsoft/vscode-azext-utils';
 import { type AzureSubscription } from '@microsoft/vscode-azureresources-api';
 import type * as vscode from 'vscode';
@@ -83,6 +83,8 @@ async function deploy(actionContext: IActionContext, arg1: vscode.Uri | string |
         return await getOrCreateFunctionApp(context)
     });
 
+    const site = await node.resolved.getSite(context);
+
     if (node.contextValue.includes('container')) {
         const learnMoreLink: string = 'https://aka.ms/deployContainerApps'
         await context.ui.showWarningMessage(localize('containerFunctionAppError', 'Deploy is not currently supported for containerized function apps within the Azure Functions extension. Please read here to learn how to deploy your project.'), { learnMoreLink });
@@ -98,19 +100,19 @@ async function deploy(actionContext: IActionContext, arg1: vscode.Uri | string |
     context.telemetry.properties.projectRuntime = version;
     context.telemetry.properties.languageModel = String(languageModel);
 
-    if (language === ProjectLanguage.Python && !node.site.isLinux) {
+    if (language === ProjectLanguage.Python && !site.isLinux) {
         context.errorHandling.suppressReportIssue = true;
         throw new Error(localize('pythonNotAvailableOnWindows', 'Python projects are not supported on Windows Function Apps. Deploy to a Linux Function App instead.'));
     }
 
-    void showCoreToolsWarning(context, version, node.site.fullName);
+    void showCoreToolsWarning(context, version, site.fullName);
 
-    const client = await node.site.createClient(actionContext);
+    const client = await site.createClient(actionContext);
     const siteConfig: SiteConfigResource = await client.getSiteConfig();
     const isConsumption: boolean = await client.getIsConsumption(actionContext);
     let isZipDeploy: boolean = siteConfig.scmType !== ScmType.LocalGit && siteConfig.scmType !== ScmType.GitHub;
-    if (!isZipDeploy && node.site.isLinux && isConsumption) {
-        ext.outputChannel.appendLog(localize('linuxConsZipOnly', 'WARNING: Using zip deploy because scm type "{0}" is not supported on Linux consumption', siteConfig.scmType), { resourceName: node.site.fullName });
+    if (!isZipDeploy && site.isLinux && isConsumption) {
+        ext.outputChannel.appendLog(localize('linuxConsZipOnly', 'WARNING: Using zip deploy because scm type "{0}" is not supported on Linux consumption', siteConfig.scmType), { resourceName: site.fullName });
         isZipDeploy = true;
         context.deployMethod = 'zip';
     }
@@ -121,10 +123,10 @@ async function deploy(actionContext: IActionContext, arg1: vscode.Uri | string |
     const doRemoteBuild: boolean | undefined = getWorkspaceSetting<boolean>(remoteBuildSetting, deployPaths.effectiveDeployFsPath) && !isFlexConsumption;
     actionContext.telemetry.properties.scmDoBuildDuringDeployment = String(doRemoteBuild);
     if (doRemoteBuild) {
-        await validateRemoteBuild(context, node.site, context.workspaceFolder, language);
+        await validateRemoteBuild(context, site, context.workspaceFolder, language);
     }
 
-    if (isZipDeploy && node.site.isLinux && isConsumption && !doRemoteBuild) {
+    if (isZipDeploy && site.isLinux && isConsumption && !doRemoteBuild) {
         context.deployMethod = 'storage';
     } else if (isFlexConsumption) {
         context.deployMethod = 'flexconsumption';
@@ -161,7 +163,7 @@ async function deploy(actionContext: IActionContext, arg1: vscode.Uri | string |
     } as unknown as ISubscriptionActionContext;
 
     const eolWarningMessage = await getEolWarningMessages(subContext, {
-        site: node.site.rawSite,
+        site: site.rawSite,
         isLinux: client.isLinux,
         isFlex: isFlexConsumption,
         client
@@ -175,7 +177,7 @@ async function deploy(actionContext: IActionContext, arg1: vscode.Uri | string |
         deploymentWarningMessages.length > 0) {
         // if there is a warning message, we want to show the deploy confirmation regardless of the setting
         const deployCommandId = 'azureFunctions.deploy';
-        await showDeployConfirmation(context, node.site, deployCommandId, deploymentWarningMessages,
+        await showDeployConfirmation(context, site, deployCommandId, deploymentWarningMessages,
             eolWarningMessage ? stackUpgradeLearnMoreLink : undefined);
     }
 
@@ -185,8 +187,8 @@ async function deploy(actionContext: IActionContext, arg1: vscode.Uri | string |
         void validateGlobSettings(context, context.effectiveDeployFsPath);
     }
 
-    if (language === ProjectLanguage.CSharp && !node.site.isLinux || durableStorageType) {
-        await updateWorkerProcessTo64BitIfRequired(context, siteConfig, node, language, durableStorageType);
+    if (language === ProjectLanguage.CSharp && !site.isLinux || durableStorageType) {
+        await updateWorkerProcessTo64BitIfRequired(context, siteConfig, site, language, durableStorageType);
     }
 
     // app settings shouldn't be checked with flex consumption plans
@@ -222,15 +224,15 @@ async function deploy(actionContext: IActionContext, arg1: vscode.Uri | string |
             }
             const deployContext = Object.assign(context, await createActivityContext());
             deployContext.activityChildren = [];
-            await innerDeploy(node.site, deployFsPath, deployContext);
+            await innerDeploy(site, deployFsPath, deployContext);
         }
     );
 
     await notifyDeployComplete(context, node, context.workspaceFolder, isFlexConsumption);
 }
 
-async function updateWorkerProcessTo64BitIfRequired(context: IDeployContext, siteConfig: SiteConfigResource, node: SlotTreeItem, language: ProjectLanguage, durableStorageType: DurableBackendValues | undefined): Promise<void> {
-    const client = await node.site.createClient(context);
+async function updateWorkerProcessTo64BitIfRequired(context: IDeployContext, siteConfig: SiteConfigResource, site: ParsedSite, language: ProjectLanguage, durableStorageType: DurableBackendValues | undefined): Promise<void> {
+    const client = await site.createClient(context);
     const config: SiteConfigResource = {
         use32BitWorkerProcess: false
     };

src/commands/deploy/deploy.ts

@@ -32,10 +32,11 @@ export async function getWarningsForConnectionSettings(context: IActionContext,
 
         const localConnectionSettings = await getConnectionSettings(localSettings.Values ?? {});
         const remoteConnectionSettings = await getConnectionSettings(options.appSettings?.properties ?? {});
+        const site = await options.node.getSite(context);
 
         if (localConnectionSettings.some(setting => setting.type === 'ManagedIdentity')) {
-            if (!options.node.site.rawSite.identity ||
-                options.node.site.rawSite.identity.type === 'None') {
+            if (!site.rawSite.identity ||
+                site.rawSite.identity.type === 'None') {
                 // if they have nothing in remote, warn them to connect a managed identity
                 return localize('configureManagedIdentityWarning',
                     'Your app is not connected to a managed identity. To ensure access, please configure a managed identity. Without it, your application may encounter authorization issues.');