Nexus Standalone: Terminate + Cancel (#9624)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: stephanos

chasm/lib/nexusoperation/config.go

@@ -186,6 +186,13 @@ var UseSystemCallbackURL = dynamicconfig.NewGlobalBoolSetting(
 When true, uses the fixed system callback URL for all worker targets.`,
 )
 
+var MaxReasonLength = dynamicconfig.NewNamespaceIntSetting(
+	"nexusoperation.limit.reasonLength",
+	1000,
+	`Limits the maximum allowed length for a reason string in Nexus operation requests.
+Uses Go's len() function to determine the length.`,
+)
+
 var UseNewFailureWireFormat = dynamicconfig.NewNamespaceBoolSetting(
 	"nexusoperation.useNewFailureWireFormat",
 	true,
@@ -210,10 +217,12 @@ type Config struct {
 	PayloadSizeLimit                    dynamicconfig.IntPropertyFnWithNamespaceFilter
 	CallbackURLTemplate                 dynamicconfig.TypedPropertyFn[*template.Template]
 	UseSystemCallbackURL                dynamicconfig.BoolPropertyFn
+	PayloadSizeLimitWarn                dynamicconfig.IntPropertyFnWithNamespaceFilter
 	UseNewFailureWireFormat             dynamicconfig.BoolPropertyFnWithNamespaceFilter
 	RecordCancelRequestCompletionEvents dynamicconfig.BoolPropertyFn
 	VisibilityMaxPageSize               dynamicconfig.IntPropertyFnWithNamespaceFilter
 	MaxIDLengthLimit                    dynamicconfig.IntPropertyFn
+	MaxReasonLength                     dynamicconfig.IntPropertyFnWithNamespaceFilter
 	RetryPolicy                         func() backoff.RetryPolicy
 }
 
@@ -233,11 +242,13 @@ func configProvider(dc *dynamicconfig.Collection, cfg *config.Persistence) *Conf
 		DisallowedOperationHeaders:         DisallowedOperationHeaders.Get(dc),
 		MaxOperationScheduleToCloseTimeout: MaxOperationScheduleToCloseTimeout.Get(dc),
 		PayloadSizeLimit:                   dynamicconfig.BlobSizeLimitError.Get(dc),
+		PayloadSizeLimitWarn:               dynamicconfig.BlobSizeLimitWarn.Get(dc),
 		CallbackURLTemplate:                CallbackURLTemplate.Get(dc),
 		UseSystemCallbackURL:               UseSystemCallbackURL.Get(dc),
 		UseNewFailureWireFormat:            UseNewFailureWireFormat.Get(dc),
 		VisibilityMaxPageSize:              dynamicconfig.FrontendVisibilityMaxPageSize.Get(dc),
 		MaxIDLengthLimit:                   dynamicconfig.MaxIDLengthLimit.Get(dc),
+		MaxReasonLength:                    MaxReasonLength.Get(dc),
 		RetryPolicy:                        RetryPolicy.Get(dc),
 	}
 }

chasm/lib/nexusoperation/frontend.go

@@ -81,7 +81,7 @@ func (h *frontendHandler) StartNexusOperationExecution(
 		return nil, err
 	}
 
-	if err := validateAndNormalizeStartRequest(req, h.config, h.saMapperProvider, h.saValidator); err != nil {
+	if err := validateAndNormalizeStartRequest(req, h.config, h.logger, h.saMapperProvider, h.saValidator); err != nil {
 		return nil, err
 	}
 
@@ -110,7 +110,7 @@ func (h *frontendHandler) DescribeNexusOperationExecution(
 		return nil, err
 	}
 
-	if err := validateDescribeNexusOperationExecutionRequest(req, h.config); err != nil {
+	if err := validateAndNormalizeDescribeRequest(req, h.config); err != nil {
 		return nil, err
 	}
 
@@ -221,23 +221,59 @@ func (h *frontendHandler) CountNexusOperationExecutions(
 }
 
 func (h *frontendHandler) RequestCancelNexusOperationExecution(
-	_ context.Context,
+	ctx context.Context,
 	req *workflowservice.RequestCancelNexusOperationExecutionRequest,
 ) (*workflowservice.RequestCancelNexusOperationExecutionResponse, error) {
 	if !h.isStandaloneNexusOperationEnabled(req.GetNamespace()) {
 		return nil, ErrStandaloneNexusOperationDisabled
 	}
-	return nil, serviceerror.NewUnimplemented("RequestCancelNexusOperationExecution not implemented")
+
+	namespaceID, err := h.namespaceRegistry.GetNamespaceID(namespace.Name(req.GetNamespace()))
+	if err != nil {
+		return nil, err
+	}
+
+	if err := validateAndNormalizeCancelRequest(req, h.config); err != nil {
+		return nil, err
+	}
+
+	_, err = h.client.RequestCancelNexusOperation(ctx, &nexusoperationpb.RequestCancelNexusOperationRequest{
+		NamespaceId:     namespaceID.String(),
+		FrontendRequest: req,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &workflowservice.RequestCancelNexusOperationExecutionResponse{}, nil
 }
 
 func (h *frontendHandler) TerminateNexusOperationExecution(
-	_ context.Context,
+	ctx context.Context,
 	req *workflowservice.TerminateNexusOperationExecutionRequest,
 ) (*workflowservice.TerminateNexusOperationExecutionResponse, error) {
 	if !h.isStandaloneNexusOperationEnabled(req.GetNamespace()) {
 		return nil, ErrStandaloneNexusOperationDisabled
 	}
-	return nil, serviceerror.NewUnimplemented("TerminateNexusOperationExecution not implemented")
+
+	namespaceID, err := h.namespaceRegistry.GetNamespaceID(namespace.Name(req.GetNamespace()))
+	if err != nil {
+		return nil, err
+	}
+
+	if err := validateAndNormalizeTerminateRequest(req, h.config); err != nil {
+		return nil, err
+	}
+
+	_, err = h.client.TerminateNexusOperation(ctx, &nexusoperationpb.TerminateNexusOperationRequest{
+		NamespaceId:     namespaceID.String(),
+		FrontendRequest: req,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &workflowservice.TerminateNexusOperationExecutionResponse{}, nil
 }
 
 func (h *frontendHandler) DeleteNexusOperationExecution(_ context.Context, req *workflowservice.DeleteNexusOperationExecutionRequest) (*workflowservice.DeleteNexusOperationExecutionResponse, error) {