Expose root execution (#454)

Fixes #415

Author: cretz

src/Temporalio/Worker/WorkflowInstance.cs

@@ -163,6 +163,13 @@ public WorkflowInstance(WorkflowInstanceDetails details)
                     RunId: start.ParentWorkflowInfo.RunId,
                     WorkflowId: start.ParentWorkflowInfo.WorkflowId);
             }
+            WorkflowInfo.RootInfo? root = null;
+            if (start.RootWorkflow != null)
+            {
+                root = new(
+                    RunId: start.RootWorkflow.RunId,
+                    WorkflowId: start.RootWorkflow.WorkflowId);
+            }
             var lastFailure = start.ContinuedFailure == null ?
                 null : failureConverter.ToException(start.ContinuedFailure, PayloadConverter);
             var lastResult = start.LastCompletionResult?.Payloads_.Select(v => new RawValue(v)).ToArray();
@@ -178,6 +185,7 @@ public WorkflowInstance(WorkflowInstanceDetails details)
                 Namespace: details.Namespace,
                 Parent: parent,
                 RetryPolicy: start.RetryPolicy == null ? null : Common.RetryPolicy.FromProto(start.RetryPolicy),
+                Root: root,
                 RunId: act.RunId,
                 RunTimeout: start.WorkflowRunTimeout?.ToTimeSpan(),
                 StartTime: act.Timestamp.ToDateTime(),

src/Temporalio/Workflows/WorkflowInfo.cs

@@ -18,6 +18,8 @@ namespace Temporalio.Workflows
     /// <param name="Namespace">Namespace for the workflow.</param>
     /// <param name="Parent">Parent information for the workflow if this is a child.</param>
     /// <param name="RetryPolicy">Retry policy for the workflow.</param>
+    /// <param name="Root">Root information for the workflow. This is nil in pre-1.27.0 server
+    /// versions or if there is no root (i.e. the root is itself).</param>
     /// <param name="RunId">Run ID for the workflow.</param>
     /// <param name="RunTimeout">Run timeout for the workflow.</param>
     /// <param name="StartTime">Time when the workflow started.</param>
@@ -40,6 +42,7 @@ public record WorkflowInfo(
         string Namespace,
         WorkflowInfo.ParentInfo? Parent,
         RetryPolicy? RetryPolicy,
+        WorkflowInfo.RootInfo? Root,
         string RunId,
         TimeSpan? RunTimeout,
         DateTime StartTime,
@@ -73,5 +76,14 @@ public record ParentInfo(
             string Namespace,
             string RunId,
             string WorkflowId);
+
+        /// <summary>
+        /// Information about a parent of a workflow.
+        /// </summary>
+        /// <param name="RunId">Run ID for the root.</param>
+        /// <param name="WorkflowId">Workflow ID for the root.</param>
+        public record RootInfo(
+            string RunId,
+            string WorkflowId);
     }
 }

tests/Temporalio.Tests/Worker/WorkflowWorkerTests.cs

@@ -373,9 +373,18 @@ public class InfoWorkflow
         public Task<WorkflowInfo> RunAsync() => Task.FromResult(Workflow.Info);
     }
 
+    [Workflow]
+    public class InfoFromChildWorkflow
+    {
+        [WorkflowRun]
+        public Task<WorkflowInfo> RunAsync() =>
+            Workflow.ExecuteChildWorkflowAsync((InfoWorkflow wf) => wf.RunAsync());
+    }
+
     [Fact]
     public async Task ExecuteWorkflowAsync_Info_Succeeds()
     {
+        // Normal info
         await ExecuteWorkerAsync<InfoWorkflow>(async worker =>
         {
             var handle = await Env.Client.StartWorkflowAsync(
@@ -389,6 +398,7 @@ await ExecuteWorkerAsync<InfoWorkflow>(async worker =>
             Assert.Equal(worker.Client.Options.Namespace, result.Namespace);
             Assert.Null(result.Parent);
             Assert.Null(result.RetryPolicy);
+            Assert.Null(result.Root);
             Assert.Equal(handle.ResultRunId, result.RunId);
             Assert.Null(result.RunTimeout);
             Assert.InRange(
@@ -401,6 +411,22 @@ await ExecuteWorkerAsync<InfoWorkflow>(async worker =>
             Assert.Equal(handle.Id, result.WorkflowId);
             Assert.Equal("InfoWorkflow", result.WorkflowType);
         });
+        // Child info
+        await ExecuteWorkerAsync<InfoFromChildWorkflow>(
+            async worker =>
+            {
+                var handle = await Env.Client.StartWorkflowAsync(
+                    (InfoFromChildWorkflow wf) => wf.RunAsync(),
+                    new(id: $"workflow-{Guid.NewGuid()}", taskQueue: worker.Options.TaskQueue!));
+                var result = await handle.GetResultAsync();
+                Assert.Equal(
+                    new WorkflowInfo.ParentInfo(Env.Client.Options.Namespace, handle.ResultRunId!, handle.Id),
+                    result.Parent);
+                Assert.Equal(
+                    new WorkflowInfo.RootInfo(handle.ResultRunId!, handle.Id),
+                    result.Root);
+            },
+            new TemporalWorkerOptions().AddWorkflow<InfoWorkflow>());
     }
 
     public record HistoryInfo(int HistoryLength, int HistorySize, bool ContinueAsNewSuggested);