Method GetTaskQueueUserData

service/frontend/admin_handler.go:1863–1916

(
	ctx context.Context,
	request *adminservice.GetTaskQueueUserDataRequest,
)

}

func (adh *AdminHandler) GetTaskQueueUserData(
	ctx context.Context,
	request *adminservice.GetTaskQueueUserDataRequest,
) (_ *adminservice.GetTaskQueueUserDataResponse, err error) {
	defer log.CapturePanic(adh.logger, &err)

	if request == nil {
		return nil, errRequestNotSet
	}
	if len(request.Namespace) == 0 {
		return nil, errNamespaceNotSet
	}

	// Admin API takes namespace name; matching requires namespace ID.
	namespaceID, err := adh.namespaceRegistry.GetNamespaceID(namespace.Name(request.GetNamespace()))
	if err != nil {
		return nil, err
	}

	// Build the partition object to get its wire-format RPC name.
	// partition_id=0 (root) → bare task queue name, e.g. "my-queue".
	// partition_id=N       → mangled name, e.g. "/_sys/my-queue/N".
	// The matching client uses this name for consistent-hash routing to the correct host,
	// and the matching engine parses it to find the right in-memory partition manager.
	// namespaceID is passed for correctness even though RpcName() only uses the task queue name.
	family, err := tqid.NewTaskQueueFamily(namespaceID.String(), request.GetTaskQueue())
	if err != nil {
		return nil, err
	}
	partition := family.TaskQueue(request.GetTaskQueueType()).NormalPartition(int(request.GetPartitionId()))

	// Fetch the user data currently loaded by the target partition.
	// LastKnownUserDataVersion=0: no cached version, always return current data.
	// LastKnownEphemeralDataVersion=-1: skip ephemeral data; we only need persisted per-type data.
	resp, err := adh.matchingClient.GetTaskQueueUserData(ctx, &matchingservice.GetTaskQueueUserDataRequest{
		NamespaceId:                   namespaceID.String(),
		TaskQueue:                     partition.RpcName(),
		TaskQueueType:                 request.GetTaskQueueType(),
		LastKnownUserDataVersion:      0,
		LastKnownEphemeralDataVersion: -1,
	})
	if err != nil {
		return nil, err
	}

	// User data is a family-level map keyed by TaskQueueType (int32).
	// Extract only the entry for the requested type and return it alongside the version,
	// so callers can compare versions across partitions to check replication lag.
	perType := resp.GetUserData().GetData().GetPerType()
	return &adminservice.GetTaskQueueUserDataResponse{
		UserData: perType[int32(request.GetTaskQueueType())],
		Version:  resp.GetUserData().GetVersion(),
	}, nil
}

func (adh *AdminHandler) DeleteWorkflowExecution(
	ctx context.Context,