feat: Update function app setting to run from external package

Author: tbarlow12

src/config.ts

@@ -22,6 +22,7 @@ export const configConstants = {
   funcCoreTools: "func",
   funcCoreToolsArgs: ["host", "start"],
   funcConsoleColor: "blue",
+  runFromPackageSetting: "WEBSITE_RUN_FROM_PACKAGE",
   jsonContentType: "application/json",
   logInvocationsApiPath: "/azurejobs/api/functions/definitions/",
   logOutputApiPath: "/azurejobs/api/log/output/",

src/plugins/login/azureLoginPlugin.test.ts

@@ -52,6 +52,7 @@ describe("Login Plugin", () => {
   });
 
   it("calls login if azure credentials are not set", async () => {
+    unsetServicePrincipalEnvVariables();
     await invokeLoginHook();
     expect(AzureLoginService.interactiveLogin).toBeCalled();
     expect(AzureLoginService.servicePrincipalLogin).not.toBeCalled();
@@ -115,7 +116,7 @@ describe("Login Plugin", () => {
     expect(sls.variables["subscriptionId"]).toEqual("azureSubId");
     expect(sls.cli.log).toBeCalledWith("Using subscription ID: azureSubId");
   });
-  
+
   it("Uses the subscription ID specified in serverless yaml", async () => {
     const sls = MockFactory.createTestServerless();
     const opt = MockFactory.createTestServerlessOptions();

src/services/baseService.ts

@@ -190,6 +190,10 @@ export abstract class BaseService {
     (this.serverless.cli.log as any)(message, entity, options);
   }
 
+  protected prettyPrint(object: any) {
+    this.log(JSON.stringify(object, null, 2));
+  }
+
   /**
    * Get function objects
    */

src/services/functionAppService.test.ts

@@ -36,6 +36,11 @@ describe("Function App Service", () => {
   const syncTriggersUrl = `${baseUrl}${app.id}/syncfunctiontriggers?api-version=2016-08-01`;
   const listFunctionsUrl = `${baseUrl}${app.id}/functions?api-version=2016-08-01`;
 
+  const appSettings = {
+    setting1: "value1",
+    setting2: "value2",
+  }
+
   beforeAll(() => {
     const axiosMock = new MockAdapter(axios);
 
@@ -65,6 +70,8 @@ describe("Function App Service", () => {
     WebSiteManagementClient.prototype.webApps = {
       get: jest.fn(() => app),
       deleteFunction: jest.fn(),
+      listApplicationSettings: jest.fn(() => Promise.resolve({ properties: { ...appSettings } })),
+      updateApplicationSettings: jest.fn(),
     } as any;
     (FunctionAppService.prototype as any).sendFile = jest.fn();
   });
@@ -155,11 +162,22 @@ describe("Function App Service", () => {
 
     beforeEach(() => {
       FunctionAppService.prototype.get = jest.fn(() => Promise.resolve(expectedSite));
+      (FunctionAppService.prototype as any).sendFile = jest.fn();
       ArmService.prototype.createDeploymentFromConfig = jest.fn(() => Promise.resolve(expectedDeployment));
       ArmService.prototype.createDeploymentFromType = jest.fn(() => Promise.resolve(expectedDeployment));
       ArmService.prototype.deployTemplate = jest.fn(() => Promise.resolve(null));
+      WebSiteManagementClient.prototype.webApps = {
+        get: jest.fn(() => app),
+        deleteFunction: jest.fn(),
+        listApplicationSettings: jest.fn(() => Promise.resolve({ properties: { ...appSettings } })),
+        updateApplicationSettings: jest.fn(),
+      } as any;
     });
 
+    afterEach(() => {
+      jest.restoreAllMocks();
+    })
+
     it("deploys ARM templates with custom configuration", async () => {
       slsService.provider["armTemplate"] = {};
 
@@ -184,63 +202,6 @@ describe("Function App Service", () => {
       expect(ArmService.prototype.deployTemplate).toBeCalledWith(expectedDeployment);
     });
 
-    it("deploys ARM template with SAS URL if running from blob URL", async() => {
-      const sasUrl = "sasUrl";
-      AzureBlobStorageService.prototype.generateBlobSasTokenUrl = jest.fn(() => Promise.resolve(sasUrl));
-
-      const newSlsService = MockFactory.createTestService();
-      newSlsService.provider["armTemplate"] = null;
-      newSlsService.provider["deployment"] = {
-        runFromBlobUrl: true,
-      }
-
-      const service = createService(MockFactory.createTestServerless({
-        service: newSlsService,
-      }));
-
-      const site = await service.deploy();
-
-      // Deploy should upload to blob FIRST and then set the SAS URL
-      // as the WEBSITE_RUN_FROM_PACKAGE setting in the template
-      const uploadFileCalls = (AzureBlobStorageService.prototype.uploadFile as any).mock.calls;
-      expect(uploadFileCalls).toHaveLength(1);
-      const call = uploadFileCalls[0];
-      expect(call[0]).toEqual("app.zip");
-      expect(call[1]).toEqual("deployment-artifacts");
-      expect(call[2]).toMatch(/myDeploymentName-t([0-9])+.zip/);
-
-      expect(site).toEqual(expectedSite);
-      expect(ArmService.prototype.createDeploymentFromConfig).not.toBeCalled();
-      expect(ArmService.prototype.createDeploymentFromType).toBeCalledWith(ArmTemplateType.Consumption);
-      // Should set parameter of arm template to include SAS URL
-      expect(ArmService.prototype.deployTemplate).toBeCalledWith({
-        ...expectedDeployment,
-        parameters: {
-          ...expectedDeployment.parameters,
-          functionAppRunFromPackage: sasUrl,
-        }
-      });
-    });
-
-    it("does not generate SAS URL if not configured", async() => {
-      AzureBlobStorageService.prototype.generateBlobSasTokenUrl = jest.fn();
-
-      const newSlsService = MockFactory.createTestService();
-      newSlsService.provider["armTemplate"] = null;
-      newSlsService.provider["deployment"] = {
-        runFromBlobUrl: false,
-      }
-
-      const service = createService(MockFactory.createTestServerless({
-        service: newSlsService,
-      }));
-
-      await service.deploy();
-
-      expect(AzureBlobStorageService.prototype.generateBlobSasTokenUrl).not.toBeCalled();
-      expect(ArmService.prototype.deployTemplate).toBeCalledWith(expectedDeployment);
-    });
-
     it("deploys ARM template from well-known configuration", async () => {
       slsService.provider["armTemplate"] = null;
       slsService.provider["type"] = "premium";
@@ -354,4 +315,75 @@ describe("Function App Service", () => {
     const service = createService(sls, options);
     expect(service.getFunctionZipFile()).toEqual("fake.zip")
   });
+
+  it("adds a new function app setting", async () => {
+    const service = createService();
+    const settingName = "TEST_SETTING";
+    const settingValue = "TEST_VALUE"
+    await service.updateFunctionAppSetting(app, settingName, settingValue);
+    expect(WebSiteManagementClient.prototype.webApps.updateApplicationSettings).toBeCalledWith(
+      "myResourceGroup",
+      "Test",
+      {
+        ...appSettings,
+        TEST_SETTING: settingValue
+      }
+    )
+  });
+
+  it("updates an existing function app setting", async () => {
+    const service = createService();
+    const settingName = "setting1";
+    const settingValue = "TEST_VALUE"
+    await service.updateFunctionAppSetting(app, settingName, settingValue);
+    expect(WebSiteManagementClient.prototype.webApps.updateApplicationSettings).toBeCalledWith(
+      "myResourceGroup",
+      "Test",
+      {
+        setting1: settingValue,
+        setting2: appSettings.setting2
+      }
+    );
+  });
+
+  describe("Updating Function App Settings", () => {
+
+    const sasUrl = "sasUrl"
+
+    beforeEach(() => {
+      FunctionAppService.prototype.updateFunctionAppSetting = jest.fn();
+      AzureBlobStorageService.prototype.generateBlobSasTokenUrl = jest.fn(() => Promise.resolve(sasUrl));
+    });
+
+    afterEach(() => {
+      (FunctionAppService.prototype.updateFunctionAppSetting as any).mockRestore();
+    });
+
+    it("updates WEBSITE_RUN_FROM_PACKAGE with SAS URL if configured to run from blob", async () => {
+      const newSlsService = MockFactory.createTestService();
+      newSlsService.provider["deployment"] = {
+        runFromBlobUrl: true,
+      }
+
+      const service = createService(MockFactory.createTestServerless({
+        service: newSlsService,
+      }));
+      await service.uploadFunctions(app);
+      expect(AzureBlobStorageService.prototype.generateBlobSasTokenUrl).toBeCalled();
+      expect(FunctionAppService.prototype.updateFunctionAppSetting).toBeCalledWith(
+        app,
+        "WEBSITE_RUN_FROM_PACKAGE",
+        sasUrl
+      );
+    });
+
+    it("does not generate SAS URL or update WEBSITE_RUN_FROM_PACKAGE if not configured to run from blob", async() => {
+      const service = createService();
+      await service.uploadFunctions(app);
+      expect(AzureBlobStorageService.prototype.generateBlobSasTokenUrl).not.toBeCalled();
+      expect(FunctionAppService.prototype.updateFunctionAppSetting).not.toBeCalled();
+    });
+  });
+
+
 });

src/services/functionAppService.ts

@@ -11,9 +11,10 @@ import { Utils } from "../shared/utils";
 import { ArmService } from "./armService";
 import { AzureBlobStorageService } from "./azureBlobStorageService";
 import { BaseService } from "./baseService";
+import configConstants from "../config";
 
 export class FunctionAppService extends BaseService {
-  private static readonly retryCount: number = 10;
+  private static readonly retryCount: number = 30;
   private static readonly retryInterval: number = 5000;
   private webClient: WebSiteManagementClient;
   private blobService: AzureBlobStorageService;
@@ -99,7 +100,7 @@ export class FunctionAppService extends BaseService {
 
         if (listFunctionsResponse.status !== 200 || listFunctionsResponse.data.value.length === 0) {
           this.log("-> Function App not ready. Retrying...");
-          throw new Error(listFunctionsResponse.data);
+          throw new Error(JSON.stringify(listFunctionsResponse.data, null, 2));
         }
 
         return listFunctionsResponse;
@@ -130,7 +131,7 @@ export class FunctionAppService extends BaseService {
 
         if (getFunctionResponse.status !== 200) {
           this.log("-> Function app not ready. Retrying...")
-          throw new Error(response.data);
+          throw new Error(JSON.stringify(response.data, null, 2));
         }
 
         return getFunctionResponse;
@@ -149,15 +150,22 @@ export class FunctionAppService extends BaseService {
 
     const functionZipFile = this.getFunctionZipFile();
     const uploadFunctionApp = this.uploadZippedArfifactToFunctionApp(functionApp, functionZipFile);
-    // If `runFromBlobUrl` is configured, the artifact will have already been uploaded
-    const uploadBlobStorage = (this.deploymentConfig.runFromBlobUrl)
-      ?
-      Promise.resolve()
-      :
-      this.uploadZippedArtifactToBlobStorage(functionZipFile)
+    const uploadBlobStorage = this.uploadZippedArtifactToBlobStorage(functionZipFile);
 
     await Promise.all([uploadFunctionApp, uploadBlobStorage]);
 
+    if (this.deploymentConfig.runFromBlobUrl) {
+      this.log("Updating function app setting to run from external package...");
+      const sasUrl = await this.blobService.generateBlobSasTokenUrl(
+        this.deploymentConfig.container,
+        this.artifactName
+      )
+      await this.updateFunctionAppSetting(
+        functionApp,
+        configConstants.runFromPackageSetting,
+        sasUrl
+      )
+    }
 
     this.log("Deployed serverless functions:")
     const serverlessFunctions = this.serverless.service.getAllFunctions();
@@ -189,13 +197,6 @@ export class FunctionAppService extends BaseService {
       ? await armService.createDeploymentFromConfig(armTemplate)
       : await armService.createDeploymentFromType(type || "consumption");
 
-    if (this.deploymentConfig.runFromBlobUrl) {
-      await this.uploadZippedArtifactToBlobStorage(this.getFunctionZipFile());
-      deployment.parameters.functionAppRunFromPackage = await this.blobService.generateBlobSasTokenUrl(
-        this.deploymentConfig.container,
-        this.artifactName
-      )
-    }
     await armService.deployTemplate(deployment);
 
     // Return function app
@@ -240,6 +241,12 @@ export class FunctionAppService extends BaseService {
     return functionZipFile;
   }
 
+  public async updateFunctionAppSetting(functionApp: Site, setting: string, value: string) {
+    const { properties } = await this.webClient.webApps.listApplicationSettings(this.resourceGroup, functionApp.name);
+    properties[setting] = value;
+    await this.webClient.webApps.updateApplicationSettings(this.resourceGroup, functionApp.name, properties);
+  }
+
   /**
    * Uploads artifact file to blob storage container
    */