Allow deployment slot settings

RELEASE_NOTES.md

@@ -1,5 +1,8 @@
 Release Notes
 =============
+## vNext
+* WebApp/Functions: Support for deployment slot settings with `slot_setting` and `slot_settings`
+
 ## 1.6.26
 * WebApp/Functions: Fix .NET on Linux deployments
 

docs/content/api-overview/resources/functions.md

@@ -45,6 +45,8 @@ The Functions builder is used to create Azure Functions accounts. It abstracts t
 | publish_as | Specifies whether to publish function as code or as a docker container. |
 | add_slot | Adds a deployment slot to the app |
 | add_slots | Adds multiple deployment slots to the app |
+| slot_setting | Sets a deployment slot setting of the function in the form "key" "value". |
+| slot_settings | Sets a list of deployment slot setting of the function as tuples in the form of ("key", "value"). |
 | health_check_path | Sets the path to your functions health check endpoint, which Azure load balancers will ping to determine which instances are healthy.|
 
 #### Post-deployment Builder Keywords

docs/content/api-overview/resources/web-app.md

@@ -55,6 +55,8 @@ The Web App builder is used to create Azure App Service accounts. It abstracts t
 | Web App | add_private_endpoints | Adds private endpoints for this Webapp to the given subnets |
 | Web App | add_slot | Adds a deployment slot to the app |
 | Web App | add_slots | Adds multiple deployment slots to the app |
+| Web App | slot_setting | Sets a deployment slot setting of the web app in the form "key" "value". |
+| Web App | slot_settings | Sets a list of deployment slot setting of the web app as tuples in the form of ("key", "value"). |
 | Web App | health_check_path | Sets the path to your functions health check endpoint, which Azure load balancers will ping to determine which instances are healthy.|
 | Web App | custom_domain | Adds custom domain to the app, containing an app service managed certificate |
 | Service Plan | service_plan_name | Sets the name of the service plan. If not set, uses the name of the web app postfixed with "-plan". |

src/Farmer/Arm/Web.fs

@@ -9,7 +9,7 @@ open System
 
 let serverFarms = ResourceType ("Microsoft.Web/serverfarms", "2018-02-01")
 let sites = ResourceType ("Microsoft.Web/sites", "2020-06-01")
-let config = ResourceType ("Microsoft.Web/sites/config", "2016-08-01")
+let config = ResourceType ("Microsoft.Web/sites/config", "2020-06-01")
 let sourceControls = ResourceType ("Microsoft.Web/sites/sourcecontrols", "2019-08-01")
 let staticSites = ResourceType ("Microsoft.Web/staticSites", "2019-12-01-preview")
 let siteExtensions = ResourceType ("Microsoft.Web/sites/siteextensions", "2020-06-01")
@@ -400,6 +400,17 @@ type Certificate =
                            canonicalName = this.DomainName |}
                 |}
 
+type SlotConfigName = 
+    { SiteName : ResourceName
+      SlotSettingNames: string Set }
+    interface IArmResource with
+        member this.ResourceId = config.resourceId(this.SiteName/"slotconfignames")
+        member this.JsonModel =
+            {| config.Create(this.SiteName/"slotconfignames", dependsOn = [ sites.resourceId  this.SiteName]) with
+                kind = "string"
+                properties = {| appSettingNames = this.SlotSettingNames |}
+            |} :> _
+
 [<AutoOpen>]
 module SiteExtensions =
     type SiteExtension =

src/Farmer/Builders/Builders.Functions.fs

@@ -323,6 +323,12 @@ type FunctionsConfig =
                 { site with AppSettings = None; ConnectionStrings = None }
                 for (_, slot) in this.CommonWebConfig.Slots |> Map.toSeq do
                     slot.ToSite site
+
+            if this.CommonWebConfig.SlotSettingNames <> Set.empty then
+                {
+                    SiteName = this.Name.ResourceName;
+                    SlotSettingNames = this.CommonWebConfig.SlotSettingNames;
+                }
         ]
 
 type FunctionsBuilder() =
@@ -343,7 +349,8 @@ type FunctionsBuilder() =
               Slots = Map.empty
               WorkerProcess = None
               ZipDeployPath = None
-              HealthCheckPath = None }
+              HealthCheckPath = None
+              SlotSettingNames = Set.empty }
           StorageAccount = derived (fun config ->
             let storage = config.Name.ResourceName.Map (sprintf "%sstorage") |> sanitiseStorage |> ResourceName
             storageAccounts.resourceId storage)

src/Farmer/Builders/Builders.WebApp.fs

@@ -178,7 +178,8 @@ type CommonWebConfig =
       Slots : Map<string,SlotConfig>
       WorkerProcess : Bitness option
       ZipDeployPath : (string*ZipDeploy.ZipDeploySlot) option
-      HealthCheckPath: string option }
+      HealthCheckPath: string option
+      SlotSettingNames: string Set }
 
 type WebAppConfig =
     { CommonWebConfig: CommonWebConfig
@@ -540,6 +541,12 @@ type WebAppConfig =
                   DomainName = customDomain
                   SslState = SslDisabled }
             | NoDomain -> ()
+
+            if this.CommonWebConfig.SlotSettingNames <> Set.empty then
+                {
+                    SiteName = this.Name.ResourceName;
+                    SlotSettingNames = this.CommonWebConfig.SlotSettingNames;
+                }
 
             yield! (PrivateEndpoint.create location this.ResourceId ["sites"] this.PrivateEndpoints)
         ]
@@ -562,7 +569,8 @@ type WebAppBuilder() =
               Slots = Map.empty
               WorkerProcess = None
               ZipDeployPath = None
-              HealthCheckPath = None }
+              HealthCheckPath = None
+              SlotSettingNames = Set.empty }
           Sku = Sku.F1
           WorkerSize = Small
           WorkerCount = 1
@@ -888,3 +896,16 @@ module Extensions =
         [<CustomOperation "health_check_path">]
         /// Specifies the path Azure load balancers will ping to check for unhealthy instances.
         member this.HealthCheckPath(state:'T, healthCheckPath:string) = this.Map state (fun x -> {x with HealthCheckPath = Some(healthCheckPath)})
+
+        /// Adds slot  settings
+        [<CustomOperation "slot_setting">]
+        member this.AddSlotSetting (state:'T, key, value) =
+            let current = this.Get state
+            { current with Settings = current.Settings.Add(key, LiteralSetting value); SlotSettingNames =current.SlotSettingNames.Add(key) }
+            |> this.Wrap state
+        [<CustomOperation "slot_settings">]
+        member this.AddSlotSettings(state:'T, settings: (string*string) list) =
+            let current = this.Get state
+            settings
+            |> List.fold (fun (state:CommonWebConfig) (key, value: string) -> { state with Settings = state.Settings.Add(key, LiteralSetting value); SlotSettingNames = state.SlotSettingNames.Add(key) }) current
+            |> this.Wrap state

src/Tests/Functions.fs

@@ -364,4 +364,63 @@ let tests = testList "Functions tests" [
             |> Seq.map (fun x-> x.ToObject<{|name:string;value:string|}> ())
         Expect.contains appSettings {|name="APPINSIGHTS_INSTRUMENTATIONKEY"; value="[reference(resourceId('shared-group', 'Microsoft.Insights/components', 'theName'), '2014-04-01').InstrumentationKey]"|} "Invalid value for APPINSIGHTS_INSTRUMENTATIONKEY"
     }
+
+    test "Supports slot settings" {
+        let functionsApp = functions { name "test"; slot_settings [ "sticky_config", "sticky_config_value"; "another_sticky_config", "another_sticky_config_value" ]} 
+
+        let scn = functionsApp |> getResources |> getResource<Web.SlotConfigName> |> List.head
+        let ws = functionsApp |> getResources |> getResource<Web.Site> |> List.head
+
+        let template = arm{ add_resource functionsApp}
+        let jobj = template.Template |> Writer.toJson |> Newtonsoft.Json.Linq.JObject.Parse
+
+        let appSettingNames = 
+            jobj.SelectTokens $"$..resources[?(@name=='{functionsApp.Name.ResourceName.Value}/slotconfignames')].properties.appSettingNames[*]" 
+            |> Seq.map (fun x -> x.ToString())
+
+        let dependencies = 
+            jobj.SelectTokens $"$..resources[?(@name=='{functionsApp.Name.ResourceName.Value}/slotconfignames')].dependsOn[*]" 
+            |> Seq.map (fun x -> x.ToString())
+
+        let expectedSettings = Map [ 
+            "sticky_config", LiteralSetting "sticky_config_value"
+            "another_sticky_config", LiteralSetting "another_sticky_config_value" ]
+
+        let settings = Expect.wantSome ws.AppSettings "AppSettings should be set"
+        Expect.containsAll  settings  expectedSettings "App settings should contain the slot settings"
+        Expect.containsAll scn.SlotSettingNames ["sticky_config"; "another_sticky_config"] "Slot config names should be set"
+        Expect.equal scn.SiteName (ResourceName "test") "Parent name should be set"
+        Expect.containsAll appSettingNames  [ "sticky_config"; "another_sticky_config"] "Slot config names should be present in template"
+        Expect.containsAll dependencies  [ $"[resourceId('Microsoft.Web/sites', '{functionsApp.Name.ResourceName.Value}')]"] "Slot config names resource should depend on web site"
+
+    }
+
+    test "Supports slot setting" {
+        let functionsApp = functions { name "test"; slot_setting "sticky_config" "sticky_config_value" } 
+
+        let scn = functionsApp |> getResources |> getResource<Web.SlotConfigName> |> List.head
+        let ws = functionsApp |> getResources |> getResource<Web.Site> |> List.head
+
+        let template = arm{ add_resource functionsApp}
+        let jobj = template.Template |> Writer.toJson |> Newtonsoft.Json.Linq.JObject.Parse
+
+        let appSettingNames = 
+            jobj.SelectTokens $"$..resources[?(@name=='{functionsApp.Name.ResourceName.Value}/slotconfignames')].properties.appSettingNames[*]" 
+            |> Seq.map (fun x -> x.ToString())
+
+        let dependencies = 
+            jobj.SelectTokens $"$..resources[?(@name=='{functionsApp.Name.ResourceName.Value}/slotconfignames')].dependsOn[*]" 
+            |> Seq.map (fun x -> x.ToString())
+
+        let expectedSettings = Map [ 
+            "sticky_config", LiteralSetting "sticky_config_value" ]
+
+        let settings = Expect.wantSome ws.AppSettings "AppSettings should be set"
+        Expect.containsAll  settings  expectedSettings "App settings should contain the slot setting"
+        Expect.containsAll scn.SlotSettingNames ["sticky_config"] "Slot config name should be set"
+        Expect.equal scn.SiteName (ResourceName "test") "Parent name should be set"
+        Expect.containsAll appSettingNames  [ "sticky_config" ] "Slot config name should be present in template"
+        Expect.containsAll dependencies  [ $"[resourceId('Microsoft.Web/sites', '{functionsApp.Name.ResourceName.Value}')]"] "Slot config names resource should depend on web site"
+
+    }
 ]

src/Tests/WebApp.fs

@@ -710,4 +710,63 @@ let tests = testList "Web App Tests" [
 
         Expect.equal hostnameBinding.Length 0 $"There should not be a hostname binding as a result of choosing the 'NoDomain' option"
     }
+
+    test "Supports slot settings" {
+        let webApp = webApp { name "test"; slot_settings [ "sticky_config", "sticky_config_value"; "another_sticky_config", "another_sticky_config_value" ]} 
+
+        let scn = webApp |> getResources |> getResource<Web.SlotConfigName> |> List.head
+        let ws = webApp |> getResources |> getResource<Web.Site> |> List.head
+
+        let template = arm{ add_resource webApp}
+        let jobj = template.Template |> Writer.toJson |> Newtonsoft.Json.Linq.JObject.Parse
+
+        let appSettingNames = 
+            jobj.SelectTokens $"$..resources[?(@name=='{webApp.Name.ResourceName.Value}/slotconfignames')].properties.appSettingNames[*]" 
+            |> Seq.map (fun x -> x.ToString())
+
+        let dependencies = 
+            jobj.SelectTokens $"$..resources[?(@name=='{webApp.Name.ResourceName.Value}/slotconfignames')].dependsOn[*]" 
+            |> Seq.map (fun x -> x.ToString())
+
+        let expectedSettings = Map [ 
+            "sticky_config", LiteralSetting "sticky_config_value"
+            "another_sticky_config", LiteralSetting "another_sticky_config_value" ]
+
+        let settings = Expect.wantSome ws.AppSettings "AppSettings should be set"
+        Expect.containsAll  settings  expectedSettings "App settings should contain the slot settings"
+        Expect.containsAll scn.SlotSettingNames ["sticky_config"; "another_sticky_config"] "Slot config names should be set"
+        Expect.equal scn.SiteName (ResourceName "test") "Parent name should be set"
+        Expect.containsAll appSettingNames  [ "sticky_config"; "another_sticky_config"] "Slot config names should be present in template"
+        Expect.containsAll dependencies  [ $"[resourceId('Microsoft.Web/sites', '{webApp.Name.ResourceName.Value}')]"] "Slot config names resource should depend on web site"
+
+    }
+
+    test "Supports slot setting" {
+          let webApp = webApp { name "test"; slot_setting "sticky_config" "sticky_config_value" } 
+
+          let scn = webApp |> getResources |> getResource<Web.SlotConfigName> |> List.head
+          let ws = webApp |> getResources |> getResource<Web.Site> |> List.head
+
+          let template = arm{ add_resource webApp}
+          let jobj = template.Template |> Writer.toJson |> Newtonsoft.Json.Linq.JObject.Parse
+
+          let appSettingNames = 
+              jobj.SelectTokens $"$..resources[?(@name=='{webApp.Name.ResourceName.Value}/slotconfignames')].properties.appSettingNames[*]" 
+              |> Seq.map (fun x -> x.ToString())
+
+          let dependencies = 
+              jobj.SelectTokens $"$..resources[?(@name=='{webApp.Name.ResourceName.Value}/slotconfignames')].dependsOn[*]" 
+              |> Seq.map (fun x -> x.ToString())
+
+          let expectedSettings = Map [ 
+              "sticky_config", LiteralSetting "sticky_config_value" ]
+
+          let settings = Expect.wantSome ws.AppSettings "AppSettings should be set"
+          Expect.containsAll  settings  expectedSettings "App settings should contain the slot setting"
+          Expect.containsAll scn.SlotSettingNames ["sticky_config"] "Slot config name should be set"
+          Expect.equal scn.SiteName (ResourceName "test") "Parent name should be set"
+          Expect.containsAll appSettingNames  [ "sticky_config" ] "Slot config name should be present in template"
+          Expect.containsAll dependencies  [ $"[resourceId('Microsoft.Web/sites', '{webApp.Name.ResourceName.Value}')]"] "Slot config names resource should depend on web site"
+
+      }
 ]