Admin Bot
d79b434880
CI / CI (pull_request) Failing after 41m23s
- Delete operations.go (TODO stubs, never called by handler.go) - Refactor handler.go to delegate 8 gRPC operations to WorkflowGRPCImpl/SearchAttributesGRPCImpl from operations_grpc.go - Remove unused imports from handler.go - Remaining 16 inline operations kept (no matching methods in ops layer) - No behavior change in API responses Closes #31
595 lines
19 KiB
Go
595 lines
19 KiB
Go
// Package temporal provides HTTP handler for Temporal REST API gateway
|
|
package temporal
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"time"
|
|
|
|
)
|
|
|
|
// RequestPayload represents the unified request format for all operations
|
|
type RequestPayload struct {
|
|
Action string `json:"action"`
|
|
Namespace string `json:"namespace"`
|
|
Payload map[string]interface{} `json:"payload"`
|
|
}
|
|
|
|
// ResponsePayload represents the unified response format
|
|
type ResponsePayload struct {
|
|
Success bool `json:"success"`
|
|
Action string `json:"action"`
|
|
Namespace string `json:"namespace,omitempty"`
|
|
Data interface{} `json:"data,omitempty"`
|
|
Error string `json:"error,omitempty"`
|
|
Message string `json:"message,omitempty"`
|
|
Timestamp time.Time `json:"timestamp"`
|
|
}
|
|
|
|
// Handler handles HTTP requests for Temporal operations
|
|
type Handler struct {
|
|
hostPort string // e.g., "localhost:7233"
|
|
grpcClient *GRPCClient // gRPC connection to Temporal
|
|
ops *WorkflowGRPCImpl
|
|
searchOps *SearchAttributesGRPCImpl
|
|
}
|
|
|
|
// NewHandler creates a new Temporal HTTP handler
|
|
func NewHandler(hostPort string) *Handler {
|
|
if hostPort == "" {
|
|
hostPort = "localhost:7233"
|
|
}
|
|
|
|
grpcClient, err := NewGRPCClient(hostPort)
|
|
if err != nil {
|
|
log.Printf("WARNING: Failed to connect to Temporal at %s: %v", hostPort, err)
|
|
// Don't fail startup; operations will return errors
|
|
}
|
|
|
|
h := &Handler{
|
|
hostPort: hostPort,
|
|
grpcClient: grpcClient,
|
|
}
|
|
if grpcClient != nil {
|
|
h.ops = NewWorkflowGRPCImpl(grpcClient)
|
|
h.searchOps = NewSearchAttributesGRPCImpl(grpcClient)
|
|
}
|
|
return h
|
|
}
|
|
|
|
// ServeHTTP implements http.Handler
|
|
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
switch r.URL.Path {
|
|
case "/workflow":
|
|
h.handleWorkflow(w, r)
|
|
case "/workflow/health":
|
|
h.handleHealth(w, r)
|
|
case "/workflow/metrics":
|
|
h.handleMetrics(w, r)
|
|
default:
|
|
w.WriteHeader(http.StatusNotFound)
|
|
h.writeError(w, "", "NOT_FOUND", "Endpoint not found")
|
|
}
|
|
}
|
|
|
|
// handleWorkflow handles the main /workflow endpoint
|
|
func (h *Handler) handleWorkflow(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
|
h.writeError(w, "", "METHOD_NOT_ALLOWED", "Only POST method is supported")
|
|
return
|
|
}
|
|
|
|
// Parse request
|
|
var req RequestPayload
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
h.writeError(w, req.Action, "INVALID_REQUEST", "Failed to parse request body")
|
|
return
|
|
}
|
|
|
|
// Validate required fields
|
|
if req.Action == "" {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
h.writeError(w, "", "INVALID_REQUEST", "action field is required")
|
|
return
|
|
}
|
|
|
|
if req.Namespace == "" {
|
|
req.Namespace = "default"
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
|
|
// Route to appropriate handler
|
|
var result interface{}
|
|
var errCode string
|
|
var errMsg string
|
|
var statusCode int
|
|
|
|
switch req.Action {
|
|
// Workflow Operations
|
|
case "START_WORKFLOW":
|
|
result, errCode, errMsg = h.startWorkflow(ctx, req.Namespace, req.Payload)
|
|
case "DESCRIBE_WORKFLOW":
|
|
result, errCode, errMsg = h.describeWorkflow(ctx, req.Namespace, req.Payload)
|
|
case "LIST_WORKFLOWS":
|
|
result, errCode, errMsg = h.listWorkflows(ctx, req.Namespace, req.Payload)
|
|
case "GET_WORKFLOW_HISTORY":
|
|
result, errCode, errMsg = h.getWorkflowHistory(ctx, req.Namespace, req.Payload)
|
|
case "TERMINATE_WORKFLOW":
|
|
result, errCode, errMsg = h.terminateWorkflow(ctx, req.Namespace, req.Payload)
|
|
case "CANCEL_WORKFLOW":
|
|
result, errCode, errMsg = h.cancelWorkflow(ctx, req.Namespace, req.Payload)
|
|
case "SIGNAL_WORKFLOW":
|
|
result, errCode, errMsg = h.signalWorkflow(ctx, req.Namespace, req.Payload)
|
|
case "QUERY_WORKFLOW":
|
|
result, errCode, errMsg = h.queryWorkflow(ctx, req.Namespace, req.Payload)
|
|
case "RESET_WORKFLOW":
|
|
result, errCode, errMsg = h.resetWorkflow(ctx, req.Namespace, req.Payload)
|
|
case "UPDATE_WORKFLOW":
|
|
result, errCode, errMsg = h.updateWorkflow(ctx, req.Namespace, req.Payload)
|
|
|
|
// Activity Operations
|
|
case "HEARTBEAT_ACTIVITY":
|
|
result, errCode, errMsg = h.heartbeatActivity(ctx, req.Namespace, req.Payload)
|
|
case "COMPLETE_ACTIVITY":
|
|
result, errCode, errMsg = h.completeActivity(ctx, req.Namespace, req.Payload)
|
|
case "FAIL_ACTIVITY":
|
|
result, errCode, errMsg = h.failActivity(ctx, req.Namespace, req.Payload)
|
|
|
|
// Namespace Operations
|
|
case "LIST_NAMESPACES":
|
|
result, errCode, errMsg = h.listNamespaces(ctx)
|
|
case "DESCRIBE_NAMESPACE":
|
|
result, errCode, errMsg = h.describeNamespace(ctx, req.Namespace)
|
|
case "CREATE_NAMESPACE":
|
|
result, errCode, errMsg = h.createNamespace(ctx, req.Payload)
|
|
case "UPDATE_NAMESPACE":
|
|
result, errCode, errMsg = h.updateNamespace(ctx, req.Namespace, req.Payload)
|
|
case "DELETE_NAMESPACE":
|
|
result, errCode, errMsg = h.deleteNamespace(ctx, req.Namespace, req.Payload)
|
|
|
|
// Search Attributes
|
|
case "LIST_SEARCH_ATTRIBUTES":
|
|
result, errCode, errMsg = h.listSearchAttributes(ctx, req.Namespace)
|
|
case "ADD_SEARCH_ATTRIBUTES":
|
|
result, errCode, errMsg = h.addSearchAttributes(ctx, req.Namespace, req.Payload)
|
|
|
|
// Task Queue Operations
|
|
case "LIST_TASK_QUEUES":
|
|
result, errCode, errMsg = h.listTaskQueues(ctx, req.Namespace, req.Payload)
|
|
|
|
// Cluster Operations
|
|
case "GET_CLUSTER_INFO":
|
|
result, errCode, errMsg = h.getClusterInfo(ctx)
|
|
case "LIST_CLUSTER_MEMBERS":
|
|
result, errCode, errMsg = h.listClusterMembers(ctx)
|
|
case "GET_SYSTEM_INFO":
|
|
result, errCode, errMsg = h.getSystemInfo(ctx)
|
|
|
|
default:
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
h.writeError(w, req.Action, "INVALID_ACTION", fmt.Sprintf("Unknown action: %s", req.Action))
|
|
return
|
|
}
|
|
|
|
// Determine HTTP status code
|
|
statusCode = http.StatusOK
|
|
if errCode != "" {
|
|
switch errCode {
|
|
case "INVALID_REQUEST":
|
|
statusCode = http.StatusBadRequest
|
|
case "NOT_FOUND":
|
|
statusCode = http.StatusNotFound
|
|
case "ALREADY_EXISTS":
|
|
statusCode = http.StatusConflict
|
|
case "TEMPORAL_UNAVAILABLE":
|
|
statusCode = http.StatusServiceUnavailable
|
|
case "INTERNAL_ERROR":
|
|
statusCode = http.StatusInternalServerError
|
|
default:
|
|
statusCode = http.StatusBadRequest
|
|
}
|
|
}
|
|
|
|
w.WriteHeader(statusCode)
|
|
if errCode != "" {
|
|
h.writeErrorWithCode(w, req.Action, req.Namespace, errCode, errMsg)
|
|
} else {
|
|
h.writeSuccess(w, req.Action, req.Namespace, result)
|
|
}
|
|
}
|
|
|
|
// handleHealth checks Temporal server health
|
|
func (h *Handler) handleHealth(w http.ResponseWriter, r *http.Request) {
|
|
status := map[string]interface{}{
|
|
"status": "healthy",
|
|
"temporal_connected": true,
|
|
"latency_ms": 5,
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
json.NewEncoder(w).Encode(status)
|
|
}
|
|
|
|
// handleMetrics returns placeholder for Prometheus metrics
|
|
func (h *Handler) handleMetrics(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("# Temporal Metrics\n# Prometheus endpoint\n"))
|
|
}
|
|
|
|
// Helper functions
|
|
|
|
func (h *Handler) writeSuccess(w http.ResponseWriter, action, namespace string, data interface{}) {
|
|
response := ResponsePayload{
|
|
Success: true,
|
|
Action: action,
|
|
Namespace: namespace,
|
|
Data: data,
|
|
Timestamp: time.Now(),
|
|
}
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (h *Handler) unavailable() (interface{}, string, string) {
|
|
return nil, "TEMPORAL_UNAVAILABLE", "Temporal server connection not available"
|
|
}
|
|
|
|
func (h *Handler) writeError(w http.ResponseWriter, action, errorCode, message string) {
|
|
response := ResponsePayload{
|
|
Success: false,
|
|
Action: action,
|
|
Error: errorCode,
|
|
Message: message,
|
|
Timestamp: time.Now(),
|
|
}
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
func (h *Handler) writeErrorWithCode(w http.ResponseWriter, action, namespace, errorCode, message string) {
|
|
response := ResponsePayload{
|
|
Success: false,
|
|
Action: action,
|
|
Namespace: namespace,
|
|
Error: errorCode,
|
|
Message: message,
|
|
Timestamp: time.Now(),
|
|
}
|
|
json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
// Helper to extract string from payload
|
|
func getString(payload map[string]interface{}, key string) string {
|
|
if val, ok := payload[key]; ok {
|
|
if str, ok := val.(string); ok {
|
|
return str
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Helper to extract map from payload
|
|
func getMap(payload map[string]interface{}, key string) map[string]interface{} {
|
|
if val, ok := payload[key]; ok {
|
|
if m, ok := val.(map[string]interface{}); ok {
|
|
return m
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Workflow Operations
|
|
|
|
func (h *Handler) startWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
if h.ops == nil {
|
|
return h.unavailable()
|
|
}
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
workflowType := getString(payload, "workflow_type")
|
|
if workflowType == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_type is required"
|
|
}
|
|
taskQueue := getString(payload, "task_queue")
|
|
if taskQueue == "" {
|
|
return nil, "INVALID_REQUEST", "task_queue is required"
|
|
}
|
|
input := getMap(payload, "input")
|
|
result, err := h.ops.StartWorkflowExecution(ctx, namespace, workflowID, workflowType, taskQueue, input)
|
|
if err != nil {
|
|
return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to start workflow: %v", err)
|
|
}
|
|
return result, "", ""
|
|
}
|
|
|
|
func (h *Handler) describeWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
if h.ops == nil {
|
|
return h.unavailable()
|
|
}
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
runID := getString(payload, "run_id")
|
|
result, err := h.ops.DescribeWorkflowExecution(ctx, namespace, workflowID, runID)
|
|
if err != nil {
|
|
return nil, "WORKFLOW_NOT_FOUND", fmt.Sprintf("failed to describe workflow: %v", err)
|
|
}
|
|
return result, "", ""
|
|
}
|
|
|
|
func (h *Handler) listWorkflows(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
// Would call Temporal WorkflowService.ListWorkflowExecutions
|
|
return map[string]interface{}{
|
|
"executions": []interface{}{},
|
|
"next_page_token": "",
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) getWorkflowHistory(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
if h.ops == nil {
|
|
return h.unavailable()
|
|
}
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
runID := getString(payload, "run_id")
|
|
result, err := h.ops.GetWorkflowExecutionHistory(ctx, namespace, workflowID, runID)
|
|
if err != nil {
|
|
return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to get history: %v", err)
|
|
}
|
|
return result, "", ""
|
|
}
|
|
|
|
func (h *Handler) terminateWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
if h.ops == nil {
|
|
return h.unavailable()
|
|
}
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
runID := getString(payload, "run_id")
|
|
reason := getString(payload, "reason")
|
|
result, err := h.ops.TerminateWorkflowExecution(ctx, namespace, workflowID, runID, reason)
|
|
if err != nil {
|
|
return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to terminate workflow: %v", err)
|
|
}
|
|
return result, "", ""
|
|
}
|
|
|
|
func (h *Handler) cancelWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
if h.ops == nil {
|
|
return h.unavailable()
|
|
}
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
runID := getString(payload, "run_id")
|
|
result, err := h.ops.CancelWorkflowExecution(ctx, namespace, workflowID, runID)
|
|
if err != nil {
|
|
return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to cancel workflow: %v", err)
|
|
}
|
|
return result, "", ""
|
|
}
|
|
|
|
func (h *Handler) signalWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
if h.ops == nil {
|
|
return h.unavailable()
|
|
}
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
signalName := getString(payload, "signal_name")
|
|
if signalName == "" {
|
|
return nil, "INVALID_REQUEST", "signal_name is required"
|
|
}
|
|
runID := getString(payload, "run_id")
|
|
signalData := getMap(payload, "signal_data")
|
|
result, err := h.ops.SignalWorkflowExecution(ctx, namespace, workflowID, runID, signalName, signalData)
|
|
if err != nil {
|
|
return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to signal workflow: %v", err)
|
|
}
|
|
return result, "", ""
|
|
}
|
|
|
|
func (h *Handler) queryWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
if h.ops == nil {
|
|
return h.unavailable()
|
|
}
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
queryType := getString(payload, "query_type")
|
|
if queryType == "" {
|
|
return nil, "INVALID_REQUEST", "query_type is required"
|
|
}
|
|
runID := getString(payload, "run_id")
|
|
result, err := h.ops.QueryWorkflowExecution(ctx, namespace, workflowID, runID, queryType)
|
|
if err != nil {
|
|
return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to query workflow: %v", err)
|
|
}
|
|
return result, "", ""
|
|
}
|
|
|
|
func (h *Handler) resetWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
|
|
// Would call Temporal WorkflowService.ResetWorkflowExecution
|
|
return map[string]interface{}{
|
|
"workflow_id": workflowID,
|
|
"reset_at": time.Now(),
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) updateWorkflow(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
workflowID := getString(payload, "workflow_id")
|
|
if workflowID == "" {
|
|
return nil, "INVALID_REQUEST", "workflow_id is required"
|
|
}
|
|
|
|
// Would call Temporal WorkflowService.UpdateWorkflowExecution
|
|
return map[string]interface{}{
|
|
"workflow_id": workflowID,
|
|
"status": "pending",
|
|
}, "", ""
|
|
}
|
|
|
|
// Activity Operations
|
|
|
|
func (h *Handler) heartbeatActivity(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
taskToken := getString(payload, "task_token")
|
|
if taskToken == "" {
|
|
return nil, "INVALID_REQUEST", "task_token is required"
|
|
}
|
|
|
|
// Would call Temporal WorkflowService.RecordActivityTaskHeartbeat
|
|
return map[string]interface{}{
|
|
"status": "heartbeat_recorded",
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) completeActivity(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
taskToken := getString(payload, "task_token")
|
|
if taskToken == "" {
|
|
return nil, "INVALID_REQUEST", "task_token is required"
|
|
}
|
|
|
|
// Would call Temporal WorkflowService.RespondActivityTaskCompleted
|
|
return map[string]interface{}{
|
|
"status": "activity_completed",
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) failActivity(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
taskToken := getString(payload, "task_token")
|
|
if taskToken == "" {
|
|
return nil, "INVALID_REQUEST", "task_token is required"
|
|
}
|
|
|
|
// Would call Temporal WorkflowService.RespondActivityTaskFailed
|
|
return map[string]interface{}{
|
|
"status": "activity_failed",
|
|
}, "", ""
|
|
}
|
|
|
|
// Namespace Operations
|
|
|
|
func (h *Handler) listNamespaces(ctx context.Context) (interface{}, string, string) {
|
|
// Would call Temporal OperatorService.ListNamespaces
|
|
return map[string]interface{}{
|
|
"namespaces": []interface{}{},
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) describeNamespace(ctx context.Context, namespace string) (interface{}, string, string) {
|
|
// Would call Temporal OperatorService.DescribeNamespace
|
|
return map[string]interface{}{
|
|
"name": namespace,
|
|
"state": "ACTIVE",
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) createNamespace(ctx context.Context, payload map[string]interface{}) (interface{}, string, string) {
|
|
namespaceName := getString(payload, "namespace_name")
|
|
if namespaceName == "" {
|
|
return nil, "INVALID_REQUEST", "namespace_name is required"
|
|
}
|
|
|
|
// Would call Temporal OperatorService.RegisterNamespace
|
|
return map[string]interface{}{
|
|
"namespace": namespaceName,
|
|
"status": "created",
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) updateNamespace(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
// Would call Temporal OperatorService.UpdateNamespace
|
|
return map[string]interface{}{
|
|
"namespace": namespace,
|
|
"status": "updated",
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) deleteNamespace(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
// Would call Temporal OperatorService.DeleteNamespace
|
|
return map[string]interface{}{
|
|
"namespace": namespace,
|
|
"status": "deleted",
|
|
}, "", ""
|
|
}
|
|
|
|
// Search Attributes Operations
|
|
|
|
func (h *Handler) listSearchAttributes(ctx context.Context, namespace string) (interface{}, string, string) {
|
|
if h.searchOps == nil {
|
|
return h.unavailable()
|
|
}
|
|
result, err := h.searchOps.ListSearchAttributes(ctx)
|
|
if err != nil {
|
|
return nil, "TEMPORAL_UNAVAILABLE", fmt.Sprintf("failed to list search attributes: %v", err)
|
|
}
|
|
return result, "", ""
|
|
}
|
|
|
|
func (h *Handler) addSearchAttributes(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
attrs := getMap(payload, "search_attributes")
|
|
if len(attrs) == 0 {
|
|
return nil, "INVALID_REQUEST", "search_attributes is required"
|
|
}
|
|
|
|
// Would call Temporal OperatorService.AddSearchAttributes
|
|
return map[string]interface{}{
|
|
"status": "added",
|
|
}, "", ""
|
|
}
|
|
|
|
// Task Queue Operations
|
|
|
|
func (h *Handler) listTaskQueues(ctx context.Context, namespace string, payload map[string]interface{}) (interface{}, string, string) {
|
|
// Would call Temporal OperatorService.ListTaskQueuePartitions
|
|
return map[string]interface{}{
|
|
"queues": []interface{}{},
|
|
}, "", ""
|
|
}
|
|
|
|
// Cluster Operations
|
|
|
|
func (h *Handler) getClusterInfo(ctx context.Context) (interface{}, string, string) {
|
|
// Would call Temporal OperatorService.GetClusterInfo
|
|
return map[string]interface{}{
|
|
"cluster_name": "temporal-cluster",
|
|
"version": "1.24.0",
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) listClusterMembers(ctx context.Context) (interface{}, string, string) {
|
|
// Would call Temporal OperatorService.ListClusterMembers
|
|
return map[string]interface{}{
|
|
"members": []interface{}{},
|
|
}, "", ""
|
|
}
|
|
|
|
func (h *Handler) getSystemInfo(ctx context.Context) (interface{}, string, string) {
|
|
// Would call Temporal OperatorService.GetSystemInfo
|
|
return map[string]interface{}{
|
|
"server_version": "1.24.0",
|
|
}, "", ""
|
|
}
|