Allow specifying dependencies for output invokes (#412)

julienp · justinvp · web-flow · commit ee8fa12208aa · 2024-12-05T14:18:59.000Z
Provider functions that take inputs as arguments, and return an output (aka output form invokes), now allow specifying a depends_on option. This allows programs to ensure that invokes are executed after things they depend on, similar to the depdends_on resource option. Fixes pulumi/pulumi#17753 --------- Co-authored-by: Justin Van Patten <jvp@justinvp.com>
diff --git a/.changes/unreleased/Improvements-412.yaml b/.changes/unreleased/Improvements-412.yaml
@@ -0,0 +1,6 @@
+component: sdk
+kind: Improvements
+body: Allow specifying dependencies for output invokes
+time: 2024-11-27T14:37:33.985033+01:00
+custom:
+    PR: "412"
diff --git a/sdk/Pulumi.Tests/Deployment/DeploymentInvokeDependsOnTests.cs b/sdk/Pulumi.Tests/Deployment/DeploymentInvokeDependsOnTests.cs
@@ -0,0 +1,110 @@
+// Copyright 2024, Pulumi Corporation
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+using Pulumi.Testing;
+using Pulumi.Tests.Mocks;
+
+namespace Pulumi.Tests
+{
+    public class DeploymentInvokeDependsOnTests
+    {
+        [Fact]
+        public async Task DeploymentInvokeDependsOn()
+        {
+
+            var mocks = new InvokeMocks();
+            var testOptions = new TestOptions();
+            var (resources, outputs) = await Deployment.TestAsync(mocks, testOptions, () =>
+            {
+                var resource = new MyCustomResource("some-resource", null, new CustomResourceOptions());
+                var deps = new InputList<Resource>();
+                deps.Add(resource);
+
+                var resultOutput = TestFunction.Invoke(new FunctionArgs(), new InvokeOutputOptions { DependsOn = deps }).Apply(result =>
+                {
+                    Assert.Equal("my value", result.TestValue);
+                    Assert.True(mocks.Resolved); // The resource should have been awaited
+                    return result;
+                });
+
+                return new Dictionary<string, object?>
+                {
+                    ["functionResult"] = resultOutput,
+                };
+            });
+
+            if (outputs["functionResult"] is Output<FunctionResult> functionResult)
+            {
+
+                // functionResult
+
+                var value = await functionResult.GetValueAsync(new FunctionResult(""));
+                Assert.Equal("my value", value.TestValue);
+            }
+            else
+            {
+                throw new Exception($"Expected result to be of type Output<FunctionResult>");
+            }
+        }
+
+        public sealed class MyArgs : ResourceArgs { }
+
+        [ResourceType("test:DeploymentInvokeDependsOnTests:resource", null)]
+        private class MyCustomResource : CustomResource
+        {
+            public MyCustomResource(string name, MyArgs? args, CustomResourceOptions? options = null)
+                : base("test:DeploymentInvokeDependsOnTests:resource", name, args ?? new MyArgs(), options)
+            {
+            }
+        }
+
+        public sealed class FunctionArgs : global::Pulumi.InvokeArgs { }
+
+        [OutputType]
+        public sealed class FunctionResult
+        {
+            [Output("testValue")]
+            public string TestValue { get; set; }
+
+            [OutputConstructor]
+            public FunctionResult(string testValue)
+            {
+                TestValue = testValue;
+            }
+        }
+
+        public static class TestFunction
+        {
+            public static Output<FunctionResult> Invoke(FunctionArgs args, InvokeOptions? options = null)
+                => global::Pulumi.Deployment.Instance.Invoke<FunctionResult>("mypkg::func", args ?? new FunctionArgs(), options);
+        }
+
+        class InvokeMocks : IMocks
+        {
+            public bool Resolved = false;
+
+
+            public Task<object> CallAsync(MockCallArgs args)
+            {
+                return Task.FromResult<object>(new Dictionary<string, object>()
+                {
+                    ["testValue"] = "my value"
+                });
+            }
+
+            public async Task<(string? id, object state)> NewResourceAsync(MockResourceArgs args)
+            {
+                await Task.Delay(3000);
+                Resolved = true;
+                return ("id", new Dictionary<string, object>());
+            }
+        }
+    }
+}
diff --git a/sdk/Pulumi/Deployment/DeploymentInstance.cs b/sdk/Pulumi/Deployment/DeploymentInstance.cs
@@ -42,13 +42,28 @@ public Output<T> Invoke<T>(
             RegisterPackageRequest? registerPackageRequest)
             => _deployment.Invoke<T>(token, args, options, registerPackageRequest);
 
+        /// <inheritdoc />
+        public Output<T> Invoke<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options,
+            RegisterPackageRequest? registerPackageRequest)
+            => _deployment.Invoke<T>(token, args, options, registerPackageRequest);
+
         /// <inheritdoc />
         public Output<T> Invoke<T>(
             string token,
             InvokeArgs args,
             InvokeOptions? options = null)
             => _deployment.Invoke<T>(token, args, options, null);
 
+        /// <inheritdoc />
+        public Output<T> Invoke<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options)
+            => _deployment.Invoke<T>(token, args, options, null);
+
         /// <inheritdoc />
         public Output<T> InvokeSingle<T>(
             string token,
@@ -57,13 +72,28 @@ public Output<T> InvokeSingle<T>(
             RegisterPackageRequest? registerPackageRequest)
             => _deployment.InvokeSingle<T>(token, args, options, registerPackageRequest);
 
+        /// <inheritdoc />
+        public Output<T> InvokeSingle<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options,
+            RegisterPackageRequest? registerPackageRequest)
+            => _deployment.InvokeSingle<T>(token, args, options, registerPackageRequest);
+
         /// <inheritdoc />
         public Output<T> InvokeSingle<T>(
             string token,
             InvokeArgs args,
             InvokeOptions? options = null)
             => _deployment.InvokeSingle<T>(token, args, options, null);
 
+        /// <inheritdoc />
+        public Output<T> InvokeSingle<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options)
+            => _deployment.InvokeSingle<T>(token, args, options, null);
+
         /// <inheritdoc />
         public Task<T> InvokeAsync<T>(
             string token,
diff --git a/sdk/Pulumi/Deployment/Deployment_Invoke.cs b/sdk/Pulumi/Deployment/Deployment_Invoke.cs
@@ -54,9 +54,18 @@ Output<T> IDeployment.Invoke<T>(
             RegisterPackageRequest? registerPackageRequest)
             => new Output<T>(RawInvoke<T>(token, args, options, registerPackageRequest));
 
+        Output<T> IDeployment.Invoke<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options,
+            RegisterPackageRequest? registerPackageRequest)
+            => new Output<T>(RawInvoke<T>(token, args, options, registerPackageRequest));
+
         Output<T> IDeployment.Invoke<T>(string token, InvokeArgs args, InvokeOptions? options)
             => new Output<T>(RawInvoke<T>(token, args, options, registerPackageRequest: null));
 
+        Output<T> IDeployment.Invoke<T>(string token, InvokeArgs args, InvokeOutputOptions options)
+        => new Output<T>(RawInvoke<T>(token, args, options, registerPackageRequest: null));
 
 
         Output<T> IDeployment.InvokeSingle<T>(
@@ -69,13 +78,30 @@ Output<T> IDeployment.InvokeSingle<T>(
             return outputResult.Apply(outputs => outputs.Values.First());
         }
 
+        Output<T> IDeployment.InvokeSingle<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options,
+            RegisterPackageRequest? registerPackageRequest)
+        {
+            var outputResult = new Output<Dictionary<string, T>>(RawInvoke<Dictionary<string, T>>(token, args, options, registerPackageRequest));
+            return outputResult.Apply(outputs => outputs.Values.First());
+        }
+
         Output<T> IDeployment.InvokeSingle<T>(string token, InvokeArgs args, InvokeOptions? options)
         {
             var outputResult = new Output<Dictionary<string, T>>(
                 RawInvoke<Dictionary<string, T>>(token, args, options, registerPackageRequest: null));
             return outputResult.Apply(outputs => outputs.Values.First());
         }
 
+        Output<T> IDeployment.InvokeSingle<T>(string token, InvokeArgs args, InvokeOutputOptions options)
+        {
+            var outputResult = new Output<Dictionary<string, T>>(
+                RawInvoke<Dictionary<string, T>>(token, args, options, registerPackageRequest: null));
+            return outputResult.Apply(outputs => outputs.Values.First());
+        }
+
         private async Task<OutputData<T>> RawInvoke<T>(
             string token,
             InvokeArgs args,
@@ -128,13 +154,27 @@ private async Task<OutputData<T>> RawInvoke<T>(
                                          isSecret: false);
             }
 
+            // Resource dependencies that will be added to the Output
+            var resourceDependencies = new HashSet<Resource>();
+            if (options is InvokeOutputOptions outputOptions)
+            {
+                var deps = outputOptions.DependsOn;
+                if (deps != null)
+                {
+                    // Wait for all the resource dependencies from dependsOn to be available before we call the invoke
+                    var resourceList = await GatherExplicitDependenciesAsync(deps).ConfigureAwait(false);
+                    await GetAllTransitivelyReferencedResourceUrnsAsync(resourceList.ToHashSet()).ConfigureAwait(false);
+                    resourceDependencies.UnionWith(resourceList);
+                }
+            }
+
             var protoArgs = serializedArgs.ToSerializationResult();
             var result = await InvokeRawAsync(token, protoArgs, options, registerPackageRequest).ConfigureAwait(false);
             var data = Pulumi.Serialization.Converter.ConvertValue<T>(err => Log.Warn(err), $"{token} result",
                                                  new Value { StructValue = result.Serialized });
             var resources = ImmutableHashSet.CreateRange(
                 result.PropertyToDependentResources.Values.SelectMany(r => r)
-                .Union(data.Resources));
+                .Union(data.Resources).Union(resourceDependencies));
             return new OutputData<T>(resources: resources,
                                      value: data.Value,
                                      isKnown: data.IsKnown,
diff --git a/sdk/Pulumi/Deployment/IDeployment.cs b/sdk/Pulumi/Deployment/IDeployment.cs
@@ -103,6 +103,22 @@ Output<T> Invoke<T>(
             InvokeArgs args,
             InvokeOptions? options = null);
 
+        /// <summary>
+        /// Dynamically invokes the function '<paramref name="token"/>', which is offered by a
+        /// provider plugin.
+        /// <para/>
+        /// The result of <see cref="Invoke{T}(string, InvokeArgs, InvokeOptions)"/> will be a <see cref="Output"/> resolved to the
+        /// result value of the provider plugin.
+        /// <para/>
+        /// The <paramref name="args"/> inputs can be a bag of computed values(including, `T`s,
+        /// <see cref="Task{TResult}"/>s, <see cref="Output{T}"/>s etc.).
+        /// </summary>
+        Output<T> Invoke<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options);
+
+
         /// <summary>
         /// Dynamically invokes the function '<paramref name="token"/>', which is offered by a
         /// provider plugin.
@@ -119,6 +135,22 @@ Output<T> Invoke<T>(
             InvokeOptions? options,
             RegisterPackageRequest? registerPackageRequest);
 
+        /// <summary>
+        /// Dynamically invokes the function '<paramref name="token"/>', which is offered by a
+        /// provider plugin.
+        /// <para/>
+        /// The result of <see cref="Invoke{T}(string, InvokeArgs, InvokeOutputOptions, RegisterPackageRequest)"/> will be a <see cref="Output"/> resolved to the
+        /// result value of the provider plugin.
+        /// <para/>
+        /// The <paramref name="args"/> inputs can be a bag of computed values(including, `T`s,
+        /// <see cref="Task{TResult}"/>s, <see cref="Output{T}"/>s etc.).
+        /// </summary>
+        Output<T> Invoke<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options,
+            RegisterPackageRequest? registerPackageRequest);
+
         /// <summary>
         /// Dynamically invokes the function '<paramref name="token"/>', which is offered by a
         /// provider plugin.
@@ -134,6 +166,21 @@ Output<T> InvokeSingle<T>(
             InvokeArgs args,
             InvokeOptions? options = null);
 
+        /// <summary>
+        /// Dynamically invokes the function '<paramref name="token"/>', which is offered by a
+        /// provider plugin.
+        /// <para/>
+        /// The result of <see cref="InvokeSingle{T}(string, InvokeArgs, InvokeOutputOptions)"/> will be a <see cref="Output"/> resolved to the
+        /// result value of the provider plugin that returns a bag of properties with a single value that is returned.
+        /// <para/>
+        /// The <paramref name="args"/> inputs can be a bag of computed values(including, `T`s,
+        /// <see cref="Task{TResult}"/>s, <see cref="Output{T}"/>s etc.).
+        /// </summary>
+        Output<T> InvokeSingle<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options);
+
         /// <summary>
         /// Dynamically invokes the function '<paramref name="token"/>', which is offered by a
         /// provider plugin.
@@ -150,6 +197,22 @@ Output<T> InvokeSingle<T>(
             InvokeOptions? options,
             RegisterPackageRequest? registerPackageRequest);
 
+        /// <summary>
+        /// Dynamically invokes the function '<paramref name="token"/>', which is offered by a
+        /// provider plugin.
+        /// <para/>
+        /// The result of <see cref="InvokeSingle{T}(string, InvokeArgs, InvokeOutputOptions, RegisterPackageRequest)"/> will be a <see cref="Output"/> resolved to the
+        /// result value of the provider plugin that returns a bag of properties with a single value that is returned.
+        /// <para/>
+        /// The <paramref name="args"/> inputs can be a bag of computed values(including, `T`s,
+        /// <see cref="Task{TResult}"/>s, <see cref="Output{T}"/>s etc.).
+        /// </summary>
+        Output<T> InvokeSingle<T>(
+            string token,
+            InvokeArgs args,
+            InvokeOutputOptions options,
+            RegisterPackageRequest? registerPackageRequest);
+
         /// <summary>
         /// Same as <see cref="InvokeAsync{T}(string, InvokeArgs, InvokeOptions)"/>, however the
         /// return value is ignored.
diff --git a/sdk/Pulumi/Deployment/InvokeOptions.cs b/sdk/Pulumi/Deployment/InvokeOptions.cs
@@ -31,4 +31,21 @@ public class InvokeOptions
         /// </summary>
         public string? PluginDownloadURL { get; set; }
     }
+
+    /// <summary>
+    /// Options to help control the behavior of <see cref="IDeployment.Invoke{T}(string, InvokeArgs, InvokeOutputOptions, RegisterPackageRequest)"/>.
+    /// </summary>
+    public class InvokeOutputOptions : InvokeOptions
+    {
+        private InputList<Resource>? _dependsOn;
+
+        /// <summary>
+        /// Optional additional explicit dependencies on resources.
+        /// </summary>
+        public InputList<Resource> DependsOn
+        {
+            get => _dependsOn ??= new InputList<Resource>();
+            set => _dependsOn = value;
+        }
+    }
 }
diff --git a/sdk/Pulumi/Pulumi.xml b/sdk/Pulumi/Pulumi.xml
