non-breaking

Author: joerage

samples/DurableTask.Named.Samples/DurableTask.Named.Samples.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>disable</Nullable>
+    <UserSecretsId>25384414-13b6-4ef1-8eeb-12236bcf0bcd</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.DurableTask.Core" />
+    <PackageReference Include="Microsoft.Azure.DurableTask.Emulator" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\DurableTask.Hosting\src\DurableTask.Hosting.csproj" />
+  </ItemGroup>
+
+</Project>

samples/DurableTask.Named.Samples/Generics/GenericActivity`1.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Jacob Viau. All rights reserved.
+// Licensed under the APACHE 2.0. See LICENSE file in the project root for full license information.
+
+using DurableTask.Core;
+
+namespace DurableTask.Named.Samples.Generics;
+
+/// <summary>
+/// An example of an open generic activity.
+/// </summary>
+/// <typeparam name="T">The open generic type.</typeparam>
+public class GenericActivity<T> : TaskActivity<T, string>
+{
+    /// <inheritdoc />
+    protected override string Execute(TaskContext context, T input)
+    {
+        return $"My generic param is {typeof(T)} with value '{input}'";
+    }
+}

samples/DurableTask.Named.Samples/Generics/GenericOrchestrationRunner.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Jacob Viau. All rights reserved.
+// Licensed under the APACHE 2.0. See LICENSE file in the project root for full license information.
+
+using DurableTask.Core;
+
+namespace DurableTask.Named.Samples.Generics;
+
+/// <summary>
+/// Runner for generic tasks example.
+/// </summary>
+public class GenericOrchestrationRunner : TaskOrchestration<string, string>
+{
+    /// <inheritdoc />
+    public override async Task<string> RunTask(OrchestrationContext context, string input)
+    {
+        string result = await context.ScheduleTask<string>(typeof(GenericActivity<int>), 10);
+        await PrintAsync(context, result);
+
+        result = await context.ScheduleTask<string>(typeof(GenericActivity<string>), "example");
+        await PrintAsync(context, result);
+
+        result = await context.ScheduleTask<string>(typeof(GenericActivity<MyClass>), new MyClass());
+        await PrintAsync(context, result);
+
+        return string.Empty;
+    }
+
+    private static Task<string> PrintAsync(OrchestrationContext context, string input)
+    {
+        return context.ScheduleTask<string>(typeof(PrintTask), input);
+    }
+
+    private class MyClass
+    {
+        public override string ToString() => "Example private class";
+    }
+}

samples/DurableTask.Named.Samples/Greetings/GetUserTask.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Jacob Viau. All rights reserved.
+// Licensed under the APACHE 2.0. See LICENSE file in the project root for full license information.
+
+using DurableTask.Core;
+
+namespace DurableTask.Named.Samples.Greetings;
+
+/// <summary>
+/// A task activity for getting a username from console.
+/// </summary>
+public class GetUserTask : TaskActivity<string, string>
+{
+    private readonly IConsole _console;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GetUserTask"/> class.
+    /// </summary>
+    /// <param name="console">The console output helper.</param>
+    public GetUserTask(IConsole console)
+    {
+        _console = console ?? throw new ArgumentNullException(nameof(console));
+    }
+
+    /// <inheritdoc />
+    protected override string Execute(TaskContext context, string input)
+    {
+        _console.WriteLine("Please enter your name:");
+        return _console.ReadLine();
+    }
+}

samples/DurableTask.Named.Samples/Greetings/GreetingsOrchestration.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Jacob Viau. All rights reserved.
+// Licensed under the APACHE 2.0. See LICENSE file in the project root for full license information.
+
+using DurableTask.Core;
+
+namespace DurableTask.Named.Samples.Greetings;
+
+/// <summary>
+/// A task orchestration for greeting a user.
+/// </summary>
+public class GreetingsOrchestration : TaskOrchestration<string, string>
+{
+    /// <inheritdoc />
+    public override async Task<string> RunTask(OrchestrationContext context, string input)
+    {
+        string user = await context.ScheduleTask<string>(typeof(GetUserTask));
+        string greeting = await context.ScheduleTask<string>(typeof(SendGreetingTask), user);
+        return greeting;
+    }
+}

samples/DurableTask.Named.Samples/Greetings/SendGreetingTask.cs

@@ -0,0 +1,43 @@
+// Copyright (c) Jacob Viau. All rights reserved.
+// Licensed under the APACHE 2.0. See LICENSE file in the project root for full license information.
+
+using DurableTask.Core;
+
+namespace DurableTask.Named.Samples.Greetings;
+
+/// <summary>
+/// A task for sending a greeting.
+/// </summary>
+public sealed class SendGreetingTask : AsyncTaskActivity<string, string>
+{
+    private readonly IConsole _console;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SendGreetingTask"/> class.
+    /// </summary>
+    /// <param name="console">The console output helper.</param>
+    public SendGreetingTask(IConsole console)
+    {
+        _console = console ?? throw new ArgumentNullException(nameof(console));
+    }
+
+    /// <inheritdoc />
+    protected override async Task<string> ExecuteAsync(TaskContext context, string user)
+    {
+        string message;
+        if (!string.IsNullOrWhiteSpace(user) && user.Equals("TimedOut"))
+        {
+            message = "GetUser Timed out!!!";
+            _console.WriteLine(message);
+        }
+        else
+        {
+            _console.WriteLine("Sending greetings to user: " + user + "...");
+            await Task.Delay(5 * 1000);
+            message = "Greeting sent to " + user;
+            _console.WriteLine(message);
+        }
+
+        return message;
+    }
+}

samples/DurableTask.Named.Samples/PrintTask.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Jacob Viau. All rights reserved.
+// Licensed under the APACHE 2.0. See LICENSE file in the project root for full license information.
+
+using DurableTask.Core;
+
+namespace DurableTask.Named.Samples;
+
+/// <summary>
+/// An activity to print to the console.
+/// </summary>
+public class PrintTask : TaskActivity<string, string>
+{
+    private readonly IConsole _console;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PrintTask"/> class.
+    /// </summary>
+    /// <param name="console">The console to print to.</param>
+    public PrintTask(IConsole console)
+    {
+        _console = console ?? throw new ArgumentNullException(nameof(console));
+    }
+
+    /// <inheritdoc />
+    protected override string Execute(TaskContext context, string input)
+    {
+        _console.WriteLine(input);
+        return string.Empty;
+    }
+}

samples/DurableTask.Named.Samples/Program.cs

@@ -0,0 +1,106 @@
+// Copyright (c) Jacob Viau. All rights reserved.
+// Licensed under the APACHE 2.0. See LICENSE file in the project root for full license information.
+
+using DurableTask.Core;
+using DurableTask.DependencyInjection;
+using DurableTask.Emulator;
+using DurableTask.Hosting;
+using DurableTask.Hosting.Options;
+using DurableTask.Named.Samples.Generics;
+using DurableTask.Named.Samples.Greetings;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using DurableTask.DependencyInjection.Extensions;
+
+namespace DurableTask.Named.Samples;
+
+/// <summary>
+/// The samples program.
+/// </summary>
+public class Program
+{
+    private static readonly string s_taskHubName = "myHub";
+
+    /// <summary>
+    /// The entry point.
+    /// </summary>
+    /// <param name="args">The supplied arguments, if any.</param>
+    /// <returns>A task that completes when this program is finished running.</returns>
+    public static Task Main(string[] args)
+    {
+        IHost host = Host.CreateDefaultBuilder(args)
+            .ConfigureAppConfiguration(builder => builder.AddUserSecrets<Program>())
+            .ConfigureServices(services =>
+            {
+                IOrchestrationService orchestrationService = UseLocalEmulator();
+
+                services.AddTaskHubWorker(s_taskHubName, (builder) =>
+                {
+                    builder
+                        .UseBuildTarget<DurableTaskHubWorker>()
+                        .WithOrchestrationService(orchestrationService)
+
+                        .UseOrchestrationMiddleware<SampleMiddleware>()
+                        .UseActivityMiddleware<SampleMiddleware>()
+
+                        .AddOrchestration<GreetingsOrchestration>()
+                        .AddOrchestration<GenericOrchestrationRunner>()
+                        .AddActivitiesFromAssembly<Program>();
+                });
+                services.AddTaskHubClient(s_taskHubName, (builder) =>
+                {
+                    builder
+                        .UseBuildTarget<DurableTaskHubClient>()
+                        .WithOrchestrationService((IOrchestrationServiceClient)orchestrationService);
+                });
+                services.Configure<TaskHubOptions>(opt =>
+                {
+                    opt.CreateIfNotExists = true;
+                });
+                services.AddSingleton<IConsole, ConsoleWrapper>();
+                services.AddHostedService<TaskEnqueuer>();
+            })
+            .UseConsoleLifetime()
+            .Build();
+
+        return host.RunAsync();
+    }
+
+    private static IOrchestrationService UseLocalEmulator()
+        => new LocalOrchestrationService();
+
+    private class TaskEnqueuer : BackgroundService
+    {
+        private readonly TaskHubClient _client;
+        private readonly IConsole _console;
+        private readonly string _instanceId = Guid.NewGuid().ToString();
+
+        public TaskEnqueuer(ITaskHubClientProvider clientProvider, IConsole console)
+        {
+            _client = ((DurableTaskHubClient)clientProvider.GetClient(s_taskHubName)).Client;
+            _console = console ?? throw new ArgumentNullException(nameof(console));
+        }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            OrchestrationInstance instance = await _client.CreateOrchestrationInstanceAsync(
+                NameVersionHelper.GetDefaultName(typeof(GenericOrchestrationRunner)),
+                NameVersionHelper.GetDefaultVersion(typeof(GenericOrchestrationRunner)),
+                _instanceId,
+                null,
+                new Dictionary<string, string>()
+                {
+                    ["CorrelationId"] = Guid.NewGuid().ToString(),
+                });
+
+            OrchestrationState result = await _client.WaitForOrchestrationAsync(
+                instance, TimeSpan.FromSeconds(60), stoppingToken);
+
+            _console.WriteLine();
+            _console.WriteLine($"Orchestration finished.");
+            _console.WriteLine($"Run stats: {result.Status}");
+            _console.WriteLine("Press Ctrl+C to exit");
+        }
+    }
+}

samples/DurableTask.Named.Samples/Properties/launchSettings.json

@@ -0,0 +1,10 @@
+{
+  "profiles": {
+    "DurableTask.Named.Samples": {
+      "commandName": "Project",
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

samples/DurableTask.Named.Samples/SampleMiddleware.cs

@@ -0,0 +1,28 @@
+using DurableTask.Core.Middleware;
+using DurableTask.DependencyInjection;
+
+namespace DurableTask.Named.Samples;
+
+/// <summary>
+/// Sample middleware
+/// </summary>
+public class SampleMiddleware : ITaskMiddleware
+{
+    private readonly IConsole _console;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SampleMiddleware"/> class.
+    /// </summary>
+    /// <param name="console">The console output helper.</param>
+    public SampleMiddleware(IConsole console)
+    {
+        _console = console;
+    }
+
+    /// <inheritdoc />
+    public Task InvokeAsync(DispatchMiddlewareContext context, Func<Task> next)
+    {
+        _console.WriteLine("In sample middleware. Dependency Injection works.");
+        return next();
+    }
+}

samples/DurableTask.Named.Samples/System/ConsoleWrapper.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Jacob Viau. All rights reserved.
+// Licensed under the APACHE 2.0. See LICENSE file in the project root for full license information.
+
+namespace System;
+
+/// <summary>
+/// Default implementation of <see cref="IConsole"/>.
+/// </summary>
+public class ConsoleWrapper : IConsole
+{
+    /// <inheritdoc />
+    public string ReadLine() => Console.ReadLine();
+
+    /// <inheritdoc />
+    public void WriteLine() => Console.WriteLine();
+
+    /// <inheritdoc />
+    public void WriteLine(string line) => Console.WriteLine(line);
+}