Reserve __temporal prefix

.editorconfig

@@ -47,6 +47,9 @@ dotnet_diagnostic.CA2237.severity = none
 # Warn on unused imports
 dotnet_diagnostic.IDE0005.severity = warning
 
+# Don't warn on using var
+dotnet_diagnostic.IDE0008.severity = none
+
 # Cannot use range operator on older versions
 dotnet_diagnostic.IDE0057.severity = none
 
@@ -186,4 +189,4 @@ dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggest
 #Style - Pattern matching
 
 #prefer pattern matching instead of is expression with type casts
-csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion

omnisharp.json

@@ -1,5 +1,8 @@
 {
   "FormattingOptions": {
     "EnableEditorConfigSupport": true
+  },
+  "RoslynExtensionsOptions": {
+    "enableAnalyzersSupport": true
   }
 }

src/Temporalio/Activities/ActivityDefinition.cs

@@ -4,6 +4,7 @@
 using System.Reflection;
 using System.Runtime.ExceptionServices;
 using System.Threading.Tasks;
+using Temporalio.Runtime;
 
 namespace Temporalio.Activities
 {
@@ -293,6 +294,11 @@ private static ActivityDefinition Create(
             Func<object?[], object?> invoker,
             MethodInfo? methodInfo)
         {
+            if (name != null && name.StartsWith(TemporalRuntime.ReservedNamePrefix))
+            {
+                throw new ArgumentException(
+                    $"Activity name {name} cannot start with {TemporalRuntime.ReservedNamePrefix}");
+            }
             // If there is a null name, which means dynamic, there must only be one parameter type
             // and it must be varargs IRawValue
             if (name == null && (
@@ -320,4 +326,4 @@ private static ActivityDefinition Create(
             return new(name, returnType, parameterTypes, requiredParameterCount, invoker, methodInfo);
         }
     }
-}
+}

src/Temporalio/Runtime/TemporalRuntime.cs

@@ -13,6 +13,11 @@ namespace Temporalio.Runtime
     /// </remarks>
     public sealed class TemporalRuntime
     {
+        /// <summary>
+        /// Prefix for reserved handler and definition names.
+        /// </summary>
+        internal const string ReservedNamePrefix = "__temporal";
+
         private static readonly Lazy<TemporalRuntime> LazyDefault =
             new(() => new TemporalRuntime(new TemporalRuntimeOptions()));
 

src/Temporalio/Worker/ActivityWorker.cs

@@ -722,4 +722,4 @@ public override void Heartbeat(HeartbeatInput input)
             }
         }
     }
-}
+}

src/Temporalio/Worker/TemporalWorkerOptions.cs

@@ -424,4 +424,4 @@ internal void OnTaskCompleted(WorkflowInstance instance, Exception? failureExcep
             }
         }
     }
-}
+}

src/Temporalio/Worker/WorkflowInstance.cs

@@ -20,6 +20,7 @@
 using Temporalio.Common;
 using Temporalio.Converters;
 using Temporalio.Exceptions;
+using Temporalio.Runtime;
 using Temporalio.Worker.Interceptors;
 using Temporalio.Workflows;
 
@@ -939,7 +940,11 @@ private Task ApplyDoUpdateAsync(DoUpdate update)
             var updates = mutableUpdates.IsValueCreated ? mutableUpdates.Value : Definition.Updates;
             if (!updates.TryGetValue(update.Name, out var updateDefn))
             {
-                updateDefn = DynamicUpdate;
+                // Do not fall back onto dynamic update if using the reserved prefix
+                if (!update.Name.StartsWith(TemporalRuntime.ReservedNamePrefix))
+                {
+                    updateDefn = DynamicUpdate;
+                }
                 if (updateDefn == null)
                 {
                     var knownUpdates = updates.Keys.OrderBy(k => k);
@@ -1140,13 +1145,13 @@ private void ApplyQueryWorkflow(QueryWorkflow query)
                     if (query.QueryType == "__stack_trace")
                     {
                         Func<string> getter = GetStackTrace;
-                        queryDefn = WorkflowQueryDefinition.CreateWithoutAttribute(
+                        queryDefn = WorkflowQueryDefinition.CreateWithoutAttributeReservedName(
                             "__stack_trace", getter);
                     }
                     else if (query.QueryType == "__temporal_workflow_metadata")
                     {
                         Func<Api.Sdk.V1.WorkflowMetadata> getter = GetWorkflowMetadata;
-                        queryDefn = WorkflowQueryDefinition.CreateWithoutAttribute(
+                        queryDefn = WorkflowQueryDefinition.CreateWithoutAttributeReservedName(
                             "__temporal_workflow_metadata", getter);
                     }
                     else
@@ -1155,7 +1160,11 @@ private void ApplyQueryWorkflow(QueryWorkflow query)
                         var queries = mutableQueries.IsValueCreated ? mutableQueries.Value : Definition.Queries;
                         if (!queries.TryGetValue(query.QueryType, out queryDefn))
                         {
-                            queryDefn = DynamicQuery;
+                            // Do not fall back onto dynamic query if using the reserved prefix
+                            if (!query.QueryType.StartsWith(TemporalRuntime.ReservedNamePrefix))
+                            {
+                                queryDefn = DynamicQuery;
+                            }
                             if (queryDefn == null)
                             {
                                 var knownQueries = queries.Keys.OrderBy(k => k);
@@ -1267,7 +1276,11 @@ private void ApplySignalWorkflow(SignalWorkflow signal)
             var signals = mutableSignals.IsValueCreated ? mutableSignals.Value : Definition.Signals;
             if (!signals.TryGetValue(signal.SignalName, out var signalDefn))
             {
-                signalDefn = DynamicSignal;
+                // Do not fall back onto dynamic signal if using the reserved prefix
+                if (!signal.SignalName.StartsWith(TemporalRuntime.ReservedNamePrefix))
+                {
+                    signalDefn = DynamicSignal;
+                }
                 if (signalDefn == null)
                 {
                     // No definition found, buffer

src/Temporalio/Workflows/Workflow.cs

@@ -1339,4 +1339,4 @@ public static class Unsafe
             public static bool IsReplaying => Context.IsReplaying;
         }
     }
-}
+}

src/Temporalio/Workflows/WorkflowDefinition.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using Temporalio.Runtime;
 
 namespace Temporalio.Workflows
 {
@@ -427,6 +428,12 @@ public static WorkflowDefinition Create(
                 }
             }
 
+            // Verify that registered names to not use our reserved prefix
+            if (name != null && name.StartsWith(TemporalRuntime.ReservedNamePrefix))
+            {
+                errs.Add($"Workflow name {name} cannot start with {TemporalRuntime.ReservedNamePrefix}");
+            }
+
             // If there are any errors, throw
             if (errs.Count > 0)
             {
@@ -525,4 +532,4 @@ private static bool IsDefinedOnBase<T>(MethodInfo method)
             }
         }
     }
-}
+}

src/Temporalio/Workflows/WorkflowQueryDefinition.cs

@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Reflection;
 using System.Threading.Tasks;
+using Temporalio.Runtime;
 
 namespace Temporalio.Workflows
 {
@@ -10,11 +11,31 @@ namespace Temporalio.Workflows
     /// </summary>
     public class WorkflowQueryDefinition
     {
+        /// <summary>
+        /// All known reserved query handler prefixes.
+        /// </summary>
+        internal static readonly string[] ReservedQueryHandlerPrefixes =
+        {
+            TemporalRuntime.ReservedNamePrefix,
+            "__stack_trace",
+            "__enhanced_stack_trace",
+        };
+
         private static readonly ConcurrentDictionary<MethodInfo, WorkflowQueryDefinition> MethodDefinitions = new();
         private static readonly ConcurrentDictionary<PropertyInfo, WorkflowQueryDefinition> PropertyDefinitions = new();
 
-        private WorkflowQueryDefinition(string? name, string? description, MethodInfo? method, Delegate? del)
+        private WorkflowQueryDefinition(string? name, string? description, MethodInfo? method, Delegate? del, bool bypassReserved = false)
         {
+            if (!bypassReserved && name != null)
+            {
+                foreach (var reservedQ in ReservedQueryHandlerPrefixes)
+                {
+                    if (name.StartsWith(reservedQ))
+                    {
+                        throw new ArgumentException($"Query handler name {name} cannot start with {reservedQ}");
+                    }
+                }
+            }
             Name = name;
             Description = description;
             Method = method;
@@ -106,6 +127,21 @@ public static WorkflowQueryDefinition CreateWithoutAttribute(
             return new(name, description, null, del);
         }
 
+        /// <summary>
+        /// Internal version of <see cref="CreateWithoutAttribute" /> that bypasses reserved name checks.
+        /// </summary>
+        /// <param name="name">Query name. Null for dynamic query.</param>
+        /// <param name="del">Query delegate.</param>
+        /// <param name="description">Optional description. WARNING: This setting is experimental.
+        /// </param>
+        /// <returns>Query definition.</returns>
+        internal static WorkflowQueryDefinition CreateWithoutAttributeReservedName(
+            string name, Delegate del, string? description = null)
+        {
+            AssertValid(del.Method, dynamic: name == null);
+            return new(name, description, null, del, bypassReserved: true);
+        }
+
         /// <summary>
         /// Gets the query name for calling or fail if no attribute or if dynamic.
         /// </summary>
@@ -168,4 +204,4 @@ private static void AssertValid(MethodInfo method, bool dynamic)
             }
         }
     }
-}
+}

src/Temporalio/Workflows/WorkflowSignalDefinition.cs

@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Reflection;
 using System.Threading.Tasks;
+using Temporalio.Runtime;
 
 namespace Temporalio.Workflows
 {
@@ -19,6 +20,10 @@ private WorkflowSignalDefinition(
             Delegate? del,
             HandlerUnfinishedPolicy unfinishedPolicy)
         {
+            if (name != null && name.StartsWith(TemporalRuntime.ReservedNamePrefix))
+            {
+                throw new ArgumentException($"Signal handler name {name} cannot start with {TemporalRuntime.ReservedNamePrefix}");
+            }
             Name = name;
             Description = description;
             Method = method;
@@ -146,4 +151,4 @@ private static void AssertValid(MethodInfo method, bool dynamic)
             }
         }
     }
-}
+}

src/Temporalio/Workflows/WorkflowUpdateDefinition.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using Temporalio.Runtime;
 
 namespace Temporalio.Workflows
 {
@@ -22,6 +23,10 @@ private WorkflowUpdateDefinition(
             Delegate? validatorDel,
             HandlerUnfinishedPolicy unfinishedPolicy)
         {
+            if (name != null && name.StartsWith(TemporalRuntime.ReservedNamePrefix))
+            {
+                throw new ArgumentException($"Update handler name {name} cannot start with {TemporalRuntime.ReservedNamePrefix}");
+            }
             Name = name;
             Description = description;
             Method = method;
@@ -190,4 +195,4 @@ private static void AssertValid(
             }
         }
     }
-}
+}

tests/Temporalio.Tests/Activities/ActivityDefinitionTests.cs

@@ -208,6 +208,13 @@ public async Task Create_WithLambda_DoesNotHaveValidMethodInfo()
         Assert.Null(defn.MethodInfo);
     }
 
+    [Fact]
+    public void Create_With_Reserved_Name_Throws()
+    {
+        var exc = Assert.ThrowsAny<Exception>(() => ActivityDefinition.Create(IHaveABadName));
+        Assert.Contains("Activity name __temporal_badname cannot start with __temporal", exc.Message);
+    }
+
     protected static void BadAct1()
     {
     }
@@ -220,6 +227,9 @@ protected static void BadAct2(ref string foo)
     [Activity]
     protected static Task GoodAct1Async() => Task.CompletedTask;
 
+    [Activity("__temporal_badname")]
+    protected static Task IHaveABadName() => Task.CompletedTask;
+
     public static class GoodActivityClassStatic
     {
         [Activity]
@@ -252,4 +262,4 @@ public class GoodActivityClassInstance
         [Activity]
         public int MyActivity(int param) => param + 5;
     }
-}
+}

tests/Temporalio.Tests/Worker/WorkflowWorkerTests.cs

@@ -2997,6 +2997,17 @@ await ExecuteWorkerAsync<DynamicWorkflow>(
                 await handle.SignalAsync(wf => wf.SomeSignalAsync("signal arg"));
                 Assert.Equal("done", await handle.QueryAsync(wf => wf.SomeQuery("query arg")));
                 Assert.Equal("done", await handle.ExecuteUpdateAsync(wf => wf.SomeUpdateAsync("update arg")));
+
+                // Verify that invocations using the reserved prefix are not forwarded to dynamic
+                // handlers
+                await handle.SignalAsync($"{TemporalRuntime.ReservedNamePrefix}_whatever", new[] { "signal arg 1" });
+                var queryExc2 = await Assert.ThrowsAsync<WorkflowQueryFailedException>(
+                    () => handle.QueryAsync<string>($"{TemporalRuntime.ReservedNamePrefix}_whatever", new[] { "query arg 1" }));
+                Assert.Contains("not found", queryExc2.Message);
+                var updateExc = await Assert.ThrowsAsync<WorkflowUpdateFailedException>(
+                    () => handle.ExecuteUpdateAsync<string>($"{TemporalRuntime.ReservedNamePrefix}_whatever", new[] { "update arg 1" }));
+                Assert.Contains("not found", updateExc.InnerException?.Message);
+
                 // Event list must be collected before the WF finishes, since when it finishes it
                 // will be evicted from the cache and the first SomeQuery event will not exist upon
                 // replay.