DurableTaskRegistry.Orchestrators.cs

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

namespace Microsoft.DurableTask;

/// <summary>
/// Container for registered <see cref="ITaskOrchestrator" />, <see cref="ITaskActivity" />,
/// and <see cref="Microsoft.DurableTask.Entities.ITaskEntity"/> implementations.
/// </summary>
public partial class DurableTaskRegistry
{
    /*
      Covers the following ways to add orchestrators.
      by type:
        Type argument
        TaskName and Type argument
        TOrchestrator generic parameter
        TaskName and TOrchestrator generic parameter
        ITaskOrchestrator singleton
        TaskName and ITaskOrchestrator singleton

      by func/action (with explicit name):
        Func{Context, Input, Task{Output}}
        Func{Context, Input, Task}
        Func{Context, Input, Output}
        Func{Context, Task{Output}}
        Func{Context, Task}
        Func{Context, Output}
        Action{Context, TInput}
        Action{Context}

      by func/action (name inferred from method or [DurableTask] attribute):
        Func{Context, Input, Task{Output}}
        Func{Context, Input, Task}
        Func{Context, Input, Output}
        Func{Context, Task{Output}}
        Func{Context, Task}
        Func{Context, Output}
        Action{Context, TInput}
        Action{Context}
    */

    /// <summary>
    /// Registers an orchestrator factory.
    /// </summary>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="type">The orchestrator type.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestrator(TaskName name, Type type)
    {
        // TODO: Compile a constructor expression for performance.
        Check.ConcreteType<ITaskOrchestrator>(type);
        return this.AddOrchestrator(name, () => (ITaskOrchestrator)Activator.CreateInstance(type));
    }

    /// <summary>
    /// Registers an orchestrator factory. The TaskName used is derived from the provided type information.
    /// </summary>
    /// <param name="type">The orchestrator type.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestrator(Type type)
        => this.AddOrchestrator(type.GetTaskName(), type);

    /// <summary>
    /// Registers an orchestrator factory.
    /// </summary>
    /// <typeparam name="TOrchestrator">The type of orchestrator to register.</typeparam>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestrator<TOrchestrator>(TaskName name)
        where TOrchestrator : class, ITaskOrchestrator
        => this.AddOrchestrator(name, typeof(TOrchestrator));

    /// <summary>
    /// Registers an orchestrator factory. The TaskName used is derived from the provided type information.
    /// </summary>
    /// <typeparam name="TOrchestrator">The type of orchestrator to register.</typeparam>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestrator<TOrchestrator>()
        where TOrchestrator : class, ITaskOrchestrator
        => this.AddOrchestrator(typeof(TOrchestrator));

    /// <summary>
    /// Registers an orchestrator singleton.
    /// </summary>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestration instance to use.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestrator(TaskName name, ITaskOrchestrator orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestrator(name, () => orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator singleton.
    /// </summary>
    /// <param name="orchestrator">The orchestration instance to use.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestrator(ITaskOrchestrator orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestrator(orchestrator.GetType().GetTaskName(), orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// </summary>
    /// <typeparam name="TInput">The orchestrator input type.</typeparam>
    /// <typeparam name="TOutput">The orchestrator output type.</typeparam>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestratorFunc<TInput, TOutput>(
        TaskName name, Func<TaskOrchestrationContext, TInput, Task<TOutput>> orchestrator)
    {
        Check.NotNull(orchestrator);
        ITaskOrchestrator wrapper = FuncTaskOrchestrator.Create(orchestrator);
        return this.AddOrchestrator(name, wrapper);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// </summary>
    /// <typeparam name="TInput">The orchestrator input type.</typeparam>
    /// <typeparam name="TOutput">The orchestrator output type.</typeparam>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestratorFunc<TInput, TOutput>(
        TaskName name, Func<TaskOrchestrationContext, TInput, TOutput> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc<TInput, TOutput>(
            name, (context, input) => Task.FromResult(orchestrator.Invoke(context, input)));
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// </summary>
    /// <typeparam name="TInput">The orchestrator input type.</typeparam>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestratorFunc<TInput>(
        TaskName name, Func<TaskOrchestrationContext, TInput, Task> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc<TInput, object?>(name, async (context, input) =>
        {
            await orchestrator(context, input);
            return null;
        });
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// </summary>
    /// <typeparam name="TOutput">The orchestrator output type.</typeparam>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestratorFunc<TOutput>(
        TaskName name, Func<TaskOrchestrationContext, Task<TOutput>> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc<object?, TOutput>(name, (context, _) => orchestrator(context));
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// </summary>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestratorFunc(TaskName name, Func<TaskOrchestrationContext, Task> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc<object?, object?>(name, async (context, _) =>
        {
            await orchestrator(context);
            return null;
        });
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// </summary>
    /// <typeparam name="TOutput">The orchestrator output type.</typeparam>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestratorFunc<TOutput>(
        TaskName name, Func<TaskOrchestrationContext, TOutput> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc<object?, TOutput>(name, (context, _) => orchestrator(context));
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// </summary>
    /// <typeparam name="TInput">The orchestrator input type.</typeparam>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestratorFunc<TInput>(
        TaskName name, Action<TaskOrchestrationContext, TInput> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc<TInput, object?>(name, (context, input) =>
        {
            orchestrator(context, input);
            return CompletedNullTask;
        });
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// </summary>
    /// <param name="name">The name of the orchestrator to register.</param>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    public DurableTaskRegistry AddOrchestratorFunc(TaskName name, Action<TaskOrchestrationContext> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc<object?, object?>(name, (context, input) =>
        {
            orchestrator(context);
            return CompletedNullTask;
        });
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// The name is inferred from a <see cref="DurableTaskAttribute"/> on the method, or the method name.
    /// </summary>
    /// <typeparam name="TInput">The orchestrator input type.</typeparam>
    /// <typeparam name="TOutput">The orchestrator output type.</typeparam>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    /// <exception cref="ArgumentException">
    /// Thrown if the name cannot be inferred from the delegate.
    /// </exception>
    public DurableTaskRegistry AddOrchestratorFunc<TInput, TOutput>(
        Func<TaskOrchestrationContext, TInput, Task<TOutput>> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc(GetTaskNameFromDelegate(orchestrator), orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// The name is inferred from a <see cref="DurableTaskAttribute"/> on the method, or the method name.
    /// </summary>
    /// <typeparam name="TInput">The orchestrator input type.</typeparam>
    /// <typeparam name="TOutput">The orchestrator output type.</typeparam>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    /// <exception cref="ArgumentException">
    /// Thrown if the name cannot be inferred from the delegate.
    /// </exception>
    public DurableTaskRegistry AddOrchestratorFunc<TInput, TOutput>(
        Func<TaskOrchestrationContext, TInput, TOutput> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc(GetTaskNameFromDelegate(orchestrator), orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// The name is inferred from a <see cref="DurableTaskAttribute"/> on the method, or the method name.
    /// </summary>
    /// <typeparam name="TInput">The orchestrator input type.</typeparam>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    /// <exception cref="ArgumentException">
    /// Thrown if the name cannot be inferred from the delegate.
    /// </exception>
    public DurableTaskRegistry AddOrchestratorFunc<TInput>(
        Func<TaskOrchestrationContext, TInput, Task> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc(GetTaskNameFromDelegate(orchestrator), orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// The name is inferred from a <see cref="DurableTaskAttribute"/> on the method, or the method name.
    /// </summary>
    /// <typeparam name="TOutput">The orchestrator output type.</typeparam>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    /// <exception cref="ArgumentException">
    /// Thrown if the name cannot be inferred from the delegate.
    /// </exception>
    public DurableTaskRegistry AddOrchestratorFunc<TOutput>(
        Func<TaskOrchestrationContext, Task<TOutput>> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc(GetTaskNameFromDelegate(orchestrator), orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// The name is inferred from a <see cref="DurableTaskAttribute"/> on the method, or the method name.
    /// </summary>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    /// <exception cref="ArgumentException">
    /// Thrown if the name cannot be inferred from the delegate.
    /// </exception>
    public DurableTaskRegistry AddOrchestratorFunc(Func<TaskOrchestrationContext, Task> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc(GetTaskNameFromDelegate(orchestrator), orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// The name is inferred from a <see cref="DurableTaskAttribute"/> on the method, or the method name.
    /// </summary>
    /// <typeparam name="TOutput">The orchestrator output type.</typeparam>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    /// <exception cref="ArgumentException">
    /// Thrown if the name cannot be inferred from the delegate.
    /// </exception>
    public DurableTaskRegistry AddOrchestratorFunc<TOutput>(
        Func<TaskOrchestrationContext, TOutput> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc(GetTaskNameFromDelegate(orchestrator), orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// The name is inferred from a <see cref="DurableTaskAttribute"/> on the method, or the method name.
    /// </summary>
    /// <typeparam name="TInput">The orchestrator input type.</typeparam>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    /// <exception cref="ArgumentException">
    /// Thrown if the name cannot be inferred from the delegate.
    /// </exception>
    public DurableTaskRegistry AddOrchestratorFunc<TInput>(
        Action<TaskOrchestrationContext, TInput> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc(GetTaskNameFromDelegate(orchestrator), orchestrator);
    }

    /// <summary>
    /// Registers an orchestrator factory, where the implementation is <paramref name="orchestrator" />.
    /// The name is inferred from a <see cref="DurableTaskAttribute"/> on the method, or the method name.
    /// </summary>
    /// <param name="orchestrator">The orchestrator implementation.</param>
    /// <returns>The same registry, for call chaining.</returns>
    /// <exception cref="ArgumentException">
    /// Thrown if the name cannot be inferred from the delegate.
    /// </exception>
    public DurableTaskRegistry AddOrchestratorFunc(Action<TaskOrchestrationContext> orchestrator)
    {
        Check.NotNull(orchestrator);
        return this.AddOrchestratorFunc(GetTaskNameFromDelegate(orchestrator), orchestrator);
    }
}