Merge branch 'main' into shopping-cart-app

Author: yuandrew

README.md

@@ -32,6 +32,8 @@ Each sample demonstrates one feature of the SDK, together with tests.
 
 - [**Dynamic mTLS hello world**](./dynamicmtls): Simple example showing how to refresh mTLS credentials. This allows for credentials to be refreshed without restarting the worker.
 
+- [**Basic apiKey hello world**](./helloworld-apiKey): Simple example of a
+Workflow Definition and an Activity Definition using API Key to authenticate with Temporal Cloud.
 ### API demonstrations
 
 - **Async activity completion**: Example of

early-return/worker/main.go

@@ -19,6 +19,8 @@ func main() {
 	w := worker.New(c, earlyreturn.TaskQueueName, worker.Options{})
 
 	w.RegisterWorkflow(earlyreturn.Workflow)
+	w.RegisterActivity(earlyreturn.CompleteTransaction)
+	w.RegisterActivity(earlyreturn.CancelTransaction)
 
 	err = w.Run(worker.InterruptCh())
 	if err != nil {

helloworld-apiKey/README.md

@@ -0,0 +1,17 @@
+### Steps to run this sample:
+1) Configure a [Temporal Server](https://github.com/temporalio/samples-go/tree/main/#how-to-use) (such as Temporal Cloud) with apiKey.
+
+2) Run the following command to start the worker
+```
+go run ./helloworld-apiKey/worker \
+    -target-host my.namespace.tmprl.cloud:7233 \
+    -namespace my.namespace \
+    -api-key CLIENT_API_KEY
+```
+3) Run the following command to start the example
+```
+go run ./helloworld-apiKey/starter \
+    -target-host my.namespace.tmprl.cloud:7233 \
+    -namespace my.namespace \
+    -api-key CLIENT_API_KEY
+```

helloworld-apiKey/helloworld.go

@@ -0,0 +1,92 @@
+package helloworldapiKey
+
+import (
+	"context"
+	"crypto/tls"
+	"flag"
+	"fmt"
+	"os"
+	"time"
+
+	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/workflow"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+// Workflow is a Hello World workflow definition.
+func Workflow(ctx workflow.Context, name string) (string, error) {
+	ao := workflow.ActivityOptions{
+		StartToCloseTimeout: 10 * time.Second,
+	}
+	ctx = workflow.WithActivityOptions(ctx, ao)
+
+	logger := workflow.GetLogger(ctx)
+	logger.Info("HelloWorld workflow started", "name", name)
+
+	var result string
+	err := workflow.ExecuteActivity(ctx, Activity, name).Get(ctx, &result)
+	if err != nil {
+		logger.Error("Activity failed.", "Error", err)
+		return "", err
+	}
+
+	logger.Info("HelloWorld workflow completed.", "result", result)
+
+	return result, nil
+}
+
+func Activity(ctx context.Context, name string) (string, error) {
+	logger := activity.GetLogger(ctx)
+	logger.Info("Activity", "name", name)
+	return "Hello " + name + "!", nil
+}
+
+// ParseClientOptionFlags parses the given arguments into client options. In
+// some cases a failure will be returned as an error, in others the process may
+// exit with help info.
+func ParseClientOptionFlags(args []string) (client.Options, error) {
+	// Parse args
+	set := flag.NewFlagSet("hello-world-api-key", flag.ExitOnError)
+	targetHost := set.String("target-host", "localhost:7233", "Host:port for the server")
+	namespace := set.String("namespace", "default", "Namespace for the server")
+	apiKey := set.String("api-key", "", "Optional API key, mutually exclusive with cert/key")
+
+	if err := set.Parse(args); err != nil {
+		return client.Options{}, fmt.Errorf("failed parsing args: %w", err)
+	}
+
+	if *apiKey == "" {
+		*apiKey = os.Getenv("TEMPORAL_CLIENT_API_KEY")
+	}
+	if *apiKey == "" {
+		return client.Options{}, fmt.Errorf("-api-key or TEMPORAL_CLIENT_API_KEY env is required required")
+	}
+
+	connectionOptions := client.ConnectionOptions{
+		TLS: &tls.Config{},
+		DialOptions: []grpc.DialOption{
+			grpc.WithUnaryInterceptor(
+				func(ctx context.Context, method string, req any, reply any, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+					return invoker(
+						metadata.AppendToOutgoingContext(ctx, "temporal-namespace", *namespace),
+						method,
+						req,
+						reply,
+						cc,
+						opts...,
+					)
+				},
+			),
+		},
+	}
+	credentials := client.NewAPIKeyStaticCredentials(*apiKey)
+
+	return client.Options{
+		HostPort:          *targetHost,
+		Namespace:         *namespace,
+		ConnectionOptions: connectionOptions,
+		Credentials:       credentials,
+	}, nil
+}

helloworld-apiKey/helloworld_test.go

@@ -0,0 +1,38 @@
+package helloworldapiKey
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+	"go.temporal.io/sdk/testsuite"
+)
+
+func Test_Workflow(t *testing.T) {
+	testSuite := &testsuite.WorkflowTestSuite{}
+	env := testSuite.NewTestWorkflowEnvironment()
+
+	// Mock activity implementation
+	env.OnActivity(Activity, mock.Anything, "Temporal").Return("Hello Temporal!", nil)
+
+	env.ExecuteWorkflow(Workflow, "Temporal")
+
+	require.True(t, env.IsWorkflowCompleted())
+	require.NoError(t, env.GetWorkflowError())
+	var result string
+	require.NoError(t, env.GetWorkflowResult(&result))
+	require.Equal(t, "Hello Temporal!", result)
+}
+
+func Test_Activity(t *testing.T) {
+	testSuite := &testsuite.WorkflowTestSuite{}
+	env := testSuite.NewTestActivityEnvironment()
+	env.RegisterActivity(Activity)
+
+	val, err := env.ExecuteActivity(Activity, "World")
+	require.NoError(t, err)
+
+	var res string
+	require.NoError(t, val.Get(&res))
+	require.Equal(t, "Hello World!", res)
+}

helloworld-apiKey/starter/main.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"github.com/temporalio/samples-go/helloworld-apiKey"
+	"go.temporal.io/sdk/client"
+)
+
+func main() {
+	// The client is a heavyweight object that should be created once per process.
+	clientOptions, err := helloworldapiKey.ParseClientOptionFlags(os.Args[1:])
+	if err != nil {
+		log.Fatalf("Invalid arguments: %v", err)
+	}
+	c, err := client.Dial(clientOptions)
+	if err != nil {
+		log.Fatalln("Unable to create client", err)
+	}
+	defer c.Close()
+
+	workflowOptions := client.StartWorkflowOptions{
+		ID:        "hello_world_workflowID",
+		TaskQueue: "hello-world-apiKey",
+	}
+
+	we, err := c.ExecuteWorkflow(context.Background(), workflowOptions, helloworldapiKey.Workflow, "Temporal")
+	if err != nil {
+		log.Fatalln("Unable to execute workflow", err)
+	}
+
+	log.Println("Started workflow", "WorkflowID", we.GetID(), "RunID", we.GetRunID())
+
+	// Synchronously wait for the workflow completion.
+	var result string
+	err = we.Get(context.Background(), &result)
+	if err != nil {
+		log.Fatalln("Unable get workflow result", err)
+	}
+	log.Println("Workflow result:", result)
+}

helloworld-apiKey/worker/main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/temporalio/samples-go/helloworld-apiKey"
+	"go.temporal.io/sdk/client"
+	"go.temporal.io/sdk/worker"
+)
+
+func main() {
+	// The client and worker are heavyweight objects that should be created once per process.
+	clientOptions, err := helloworldapiKey.ParseClientOptionFlags(os.Args[1:])
+	if err != nil {
+		log.Fatalf("Invalid arguments: %v", err)
+	}
+	c, err := client.Dial(clientOptions)
+	if err != nil {
+		log.Fatalln("Unable to create client", err)
+	}
+	defer c.Close()
+
+	w := worker.New(c, "hello-world-apiKey", worker.Options{})
+
+	w.RegisterWorkflow(helloworldapiKey.Workflow)
+	w.RegisterActivity(helloworldapiKey.Activity)
+
+	err = w.Run(worker.InterruptCh())
+	if err != nil {
+		log.Fatalln("Unable to start worker", err)
+	}
+}

safe_message_handler/workflow.go

@@ -314,10 +314,14 @@ func (cm *ClusterManager) run(ctx workflow.Context) (ClusterManagerResult, error
 				return ClusterManagerResult{}, err
 			}
 			cm.logger.Info("Continuing as new")
-			return ClusterManagerResult{}, workflow.NewContinueAsNewError(ctx, ClusterManagerInput{
-				State:             &cm.state,
-				TestContinueAsNew: cm.testContinueAsNew,
-			})
+			return ClusterManagerResult{}, workflow.NewContinueAsNewError(
+				ctx,
+				ClusterManagerWorkflow,
+				ClusterManagerInput{
+					State:             &cm.state,
+					TestContinueAsNew: cm.testContinueAsNew,
+				},
+			)
 		}
 
 	}