Add Worker snippets for Java, .NET, TS, and Ruby

features/snippets/worker/worker.cs

@@ -1,5 +1,8 @@
+using Temporalio.Activities;
 using Temporalio.Client;
+using Temporalio.Common;
 using Temporalio.Worker;
+using Temporalio.Workflows;
 
 public class WorkerSnippet
 {
@@ -16,4 +19,116 @@ public static async Task Run()
             });
         // @@@SNIPEND
     }
+
+    public static async Task CreateWorker()
+    {
+        var client = await TemporalClient.ConnectAsync(new("localhost:7233"));
+
+        // @@@SNIPSTART dotnet-create-worker
+        var options = new TemporalWorkerOptions("my-task-queue");
+        options.AddWorkflow<GreetingWorkflow>();
+        options.AddAllActivities(typeof(GreetingActivities), null);
+
+        using var worker = new TemporalWorker(client, options);
+        await worker.ExecuteAsync(CancellationToken.None);
+        // @@@SNIPEND
+    }
+
+    public static async Task CreateVersionedWorker()
+    {
+        var client = await TemporalClient.ConnectAsync(new("localhost:7233"));
+
+        // @@@SNIPSTART dotnet-versioned-worker
+        var options = new TemporalWorkerOptions("my-task-queue")
+        {
+            DeploymentOptions = new WorkerDeploymentOptions(
+                new WorkerDeploymentVersion("my-app", "1.0"),
+                useWorkerVersioning: true),
+        };
+        options.AddWorkflow<VersionedGreetingWorkflow>();
+        options.AddAllActivities(typeof(GreetingActivities), null);
+
+        using var worker = new TemporalWorker(client, options);
+        // @@@SNIPEND
+        await Task.CompletedTask;
+    }
+
+    // A Serverless Worker on GCP Cloud Run is a standard long-lived Worker that reads its
+    // connection settings from the environment and enables Worker Versioning.
+    public static async Task CloudRunWorker()
+    {
+        // @@@SNIPSTART dotnet-cloud-run-worker
+        var client = await TemporalClient.ConnectAsync(
+            new(Environment.GetEnvironmentVariable("TEMPORAL_ADDRESS")!)
+            {
+                Namespace = Environment.GetEnvironmentVariable("TEMPORAL_NAMESPACE")!,
+                ApiKey = Environment.GetEnvironmentVariable("TEMPORAL_API_KEY"),
+                Tls = new(),
+            });
+
+        var options = new TemporalWorkerOptions(
+            Environment.GetEnvironmentVariable("TEMPORAL_TASK_QUEUE")!)
+        {
+            DeploymentOptions = new(new("my-app", "build-1"), useWorkerVersioning: true)
+            {
+                DefaultVersioningBehavior = VersioningBehavior.Pinned,
+            },
+        };
+        options.AddWorkflow<GreetingWorkflow>();
+        options.AddAllActivities(typeof(GreetingActivities), null);
+
+        using var worker = new TemporalWorker(client, options);
+        await worker.ExecuteAsync(CancellationToken.None);
+        // @@@SNIPEND
+    }
+
+    public static async Task ShutdownWorker()
+    {
+        var client = await TemporalClient.ConnectAsync(new("localhost:7233"));
+
+        // @@@SNIPSTART dotnet-worker-graceful-shutdown
+        using var tokenSource = new CancellationTokenSource();
+        Console.CancelKeyPress += (_, eventArgs) =>
+        {
+            tokenSource.Cancel();
+            eventArgs.Cancel = true;
+        };
+
+        var options = new TemporalWorkerOptions("my-task-queue")
+        {
+            GracefulShutdownTimeout = TimeSpan.FromSeconds(30),
+        };
+        options.AddWorkflow<GreetingWorkflow>();
+
+        using var worker = new TemporalWorker(client, options);
+        await worker.ExecuteAsync(tokenSource.Token);
+        // @@@SNIPEND
+    }
+
+    public static class GreetingActivities
+    {
+        [Activity]
+        public static string SayHello(string name) => $"Hello, {name}!";
+    }
+
+    [Workflow]
+    public class GreetingWorkflow
+    {
+        [WorkflowRun]
+        public async Task<string> RunAsync(string name) =>
+            await Workflow.ExecuteActivityAsync(
+                () => GreetingActivities.SayHello(name),
+                new() { StartToCloseTimeout = TimeSpan.FromSeconds(10) });
+    }
+
+    // A versioning behavior is only valid on a Worker that has versioning enabled.
+    [Workflow(VersioningBehavior = VersioningBehavior.Pinned)]
+    public class VersionedGreetingWorkflow
+    {
+        [WorkflowRun]
+        public async Task<string> RunAsync(string name) =>
+            await Workflow.ExecuteActivityAsync(
+                () => GreetingActivities.SayHello(name),
+                new() { StartToCloseTimeout = TimeSpan.FromSeconds(10) });
+    }
 }

features/snippets/worker/worker.java

@@ -1,10 +1,63 @@
+import io.temporal.activity.ActivityInterface;
+import io.temporal.activity.ActivityMethod;
 import io.temporal.client.WorkflowClient;
+import io.temporal.client.WorkflowClientOptions;
+import io.temporal.common.VersioningBehavior;
+import io.temporal.common.WorkerDeploymentVersion;
 import io.temporal.serviceclient.WorkflowServiceStubs;
+import io.temporal.serviceclient.WorkflowServiceStubsOptions;
 import io.temporal.worker.Worker;
+import io.temporal.worker.WorkerDeploymentOptions;
 import io.temporal.worker.WorkerFactory;
 import io.temporal.worker.WorkerFactoryOptions;
+import io.temporal.worker.WorkerOptions;
+import io.temporal.workflow.WorkflowInterface;
+import io.temporal.workflow.WorkflowMethod;
+import io.temporal.workflow.WorkflowVersioningBehavior;
+import java.util.concurrent.TimeUnit;
 
 class WorkerSnippet {
+  @ActivityInterface
+  public interface GreetingActivities {
+    @ActivityMethod
+    String sayHello(String name);
+  }
+
+  public static class GreetingActivitiesImpl implements GreetingActivities {
+    @Override
+    public String sayHello(String name) {
+      return "Hello, " + name + "!";
+    }
+  }
+
+  @WorkflowInterface
+  public interface GreetingWorkflow {
+    @WorkflowMethod
+    String greet(String name);
+  }
+
+  public static class GreetingWorkflowImpl implements GreetingWorkflow {
+    @Override
+    public String greet(String name) {
+      return "Hello, " + name + "!";
+    }
+  }
+
+  @WorkflowInterface
+  public interface VersionedGreetingWorkflow {
+    @WorkflowMethod
+    String greet(String name);
+  }
+
+  // A versioning behavior is only valid on a Worker that has versioning enabled.
+  public static class VersionedGreetingWorkflowImpl implements VersionedGreetingWorkflow {
+    @Override
+    @WorkflowVersioningBehavior(VersioningBehavior.PINNED)
+    public String greet(String name) {
+      return "Hello, " + name + "!";
+    }
+  }
+
   public static void main(String[] args) {
     WorkflowServiceStubs service = WorkflowServiceStubs.newLocalServiceStubs();
     WorkflowClient client = WorkflowClient.newInstance(service);
@@ -18,4 +71,90 @@ public static void main(String[] args) {
 
     factory.start();
   }
+
+  static void createWorker(WorkflowClient client) {
+    // @@@SNIPSTART java-create-worker
+    WorkerFactory factory = WorkerFactory.newInstance(client);
+
+    Worker worker = factory.newWorker("my-task-queue");
+    worker.registerWorkflowImplementationTypes(GreetingWorkflowImpl.class);
+    worker.registerActivitiesImplementations(new GreetingActivitiesImpl());
+
+    factory.start();
+    // @@@SNIPEND
+  }
+
+  static void createVersionedWorker(WorkflowClient client) {
+    WorkerFactory factory = WorkerFactory.newInstance(client);
+
+    // @@@SNIPSTART java-versioned-worker
+    WorkerOptions options =
+        WorkerOptions.newBuilder()
+            .setDeploymentOptions(
+                WorkerDeploymentOptions.newBuilder()
+                    .setVersion(new WorkerDeploymentVersion("my-app", "1.0"))
+                    .setUseVersioning(true)
+                    .build())
+            .build();
+
+    Worker worker = factory.newWorker("my-task-queue", options);
+    worker.registerWorkflowImplementationTypes(VersionedGreetingWorkflowImpl.class);
+    worker.registerActivitiesImplementations(new GreetingActivitiesImpl());
+    // @@@SNIPEND
+
+    factory.start();
+  }
+
+  // A Serverless Worker on GCP Cloud Run is a standard long-lived Worker that reads its
+  // connection settings from the environment and enables Worker Versioning.
+  static void cloudRunWorker() {
+    // @@@SNIPSTART java-cloud-run-worker
+    String apiKey = System.getenv("TEMPORAL_API_KEY");
+
+    WorkflowServiceStubs service =
+        WorkflowServiceStubs.newServiceStubs(
+            WorkflowServiceStubsOptions.newBuilder()
+                .setTarget(System.getenv("TEMPORAL_ADDRESS"))
+                .setEnableHttps(true)
+                .addApiKey(() -> apiKey)
+                .build());
+
+    WorkflowClient client =
+        WorkflowClient.newInstance(
+            service,
+            WorkflowClientOptions.newBuilder()
+                .setNamespace(System.getenv("TEMPORAL_NAMESPACE"))
+                .build());
+
+    WorkerFactory factory = WorkerFactory.newInstance(client);
+
+    Worker worker =
+        factory.newWorker(
+            System.getenv("TEMPORAL_TASK_QUEUE"),
+            WorkerOptions.newBuilder()
+                .setDeploymentOptions(
+                    WorkerDeploymentOptions.newBuilder()
+                        .setUseVersioning(true)
+                        .setVersion(new WorkerDeploymentVersion("my-app", "build-1"))
+                        .setDefaultVersioningBehavior(VersioningBehavior.PINNED)
+                        .build())
+                .build());
+
+    worker.registerWorkflowImplementationTypes(GreetingWorkflowImpl.class);
+    worker.registerActivitiesImplementations(new GreetingActivitiesImpl());
+
+    factory.start();
+    // @@@SNIPEND
+  }
+
+  static void shutdownWorker(WorkflowClient client) {
+    WorkerFactory factory = WorkerFactory.newInstance(client);
+    factory.newWorker("my-task-queue");
+    factory.start();
+
+    // @@@SNIPSTART java-worker-graceful-shutdown
+    factory.shutdown();
+    factory.awaitTermination(30, TimeUnit.SECONDS);
+    // @@@SNIPEND
+  }
 }