TestNewExecution_ConflictPolicy_TerminateExisting

go.temporal.io/server/service/history/workflow/mutable_state_impl.go 691 covered LOC · 184 ranges

Open complete file

298 runID string,

299 startTime time.Time,

300 > ) *MutableStateImpl { mutable_state_impl.go

301 >

302 > namespaceName := namespaceEntry.Name().String()

303 > logger = log.NewLazyLogger(logger, func() []tag.Tag {

304 return []tag.Tag{

305 tag.WorkflowNamespace(namespaceName),

309 })

310

311 > s := &MutableStateImpl{ mutable_state_impl.go

312 > updateActivityInfos: make(map[int64]*persistencespb.ActivityInfo),

313 > pendingActivityTimerHeartbeats: make(map[int64]time.Time),

314 > pendingActivityInfoIDs: make(map[int64]*persistencespb.ActivityInfo),

315 > pendingActivityIDToEventID: make(map[string]int64),

316 > deleteActivityInfos: make(map[int64]struct{}),

317 > syncActivityTasks: make(map[int64]struct{}),

318 >

319 > pendingTimerInfoIDs: make(map[string]*persistencespb.TimerInfo),

320 > pendingTimerEventIDToID: make(map[int64]string),

321 > updateTimerInfos: make(map[string]*persistencespb.TimerInfo),

322 > deleteTimerInfos: make(map[string]struct{}),

323 >

324 > updateChildExecutionInfos: make(map[int64]*persistencespb.ChildExecutionInfo),

325 > pendingChildExecutionInfoIDs: make(map[int64]*persistencespb.ChildExecutionInfo),

326 > deleteChildExecutionInfos: make(map[int64]struct{}),

327 >

328 > updateRequestCancelInfos: make(map[int64]*persistencespb.RequestCancelInfo),

329 > pendingRequestCancelInfoIDs: make(map[int64]*persistencespb.RequestCancelInfo),

330 > deleteRequestCancelInfos: make(map[int64]struct{}),

331 >

332 > updateSignalInfos: make(map[int64]*persistencespb.SignalInfo),

333 > pendingSignalInfoIDs: make(map[int64]*persistencespb.SignalInfo),

334 > deleteSignalInfos: make(map[int64]struct{}),

335 >

336 > updateSignalRequestedIDs: make(map[string]struct{}),

337 > pendingSignalRequestedIDs: make(map[string]struct{}),

338 > deleteSignalRequestedIDs: make(map[string]struct{}),

339 >

340 > // This field will be initialized with a real chasm tree at the end of this function

341 > // when feature flag is enabled.

342 > chasmTree: &noopChasmTree{},

343 >

344 > approximateSize: 0,

345 > chasmNodeSizes: make(map[string]int),

346 > totalTombstones: 0,

347 > currentVersion: namespaceEntry.FailoverVersion(workflowID),

348 > bufferEventsInDB: nil,

349 > stateInDB: enumsspb.WORKFLOW_EXECUTION_STATE_VOID,

350 > nextEventIDInDB: common.FirstEventID,

351 > dbRecordVersion: 1,

352 > namespaceEntry: namespaceEntry,

353 > appliedEvents: make(map[string]struct{}),

354 > InsertTasks: make(map[tasks.Category][]tasks.Task),

355 > BestEffortDeleteTasks: make(map[tasks.Category][]tasks.Key),

356 > transitionHistoryEnabled: shard.GetConfig().EnableTransitionHistory(namespaceName),

357 > visibilityUpdated: false,

358 > executionStateUpdated: false,

359 > workflowTaskUpdated: false,

360 > updateInfoUpdated: make(map[string]struct{}),

361 > timerInfosUserDataUpdated: make(map[string]struct{}),

362 > activityInfosUserDataUpdated: make(map[int64]struct{}),

363 > reapplyEventsCandidate: []*historypb.HistoryEvent{},

364 >

365 > QueryRegistry: NewQueryRegistry(),

366 >

367 > shard: shard,

368 > clusterMetadata: shard.GetClusterMetadata(),

369 > eventsCache: eventsCache,

370 > config: shard.GetConfig(),

371 > timeSource: shard.GetTimeSource(),

372 > logger: logger,

373 > metricsHandler: shard.GetMetricsHandler().WithTags(metrics.OperationTag(metrics.WorkflowContextScope)),

374 > endpointRegistry: shard.EndpointRegistry(),

375 > }

376 >

377 > s.executionInfo = &persistencespb.WorkflowExecutionInfo{

378 > NamespaceId: namespaceEntry.ID().String(),

379 > WorkflowId: workflowID,

380 >

381 > WorkflowTaskVersion: common.EmptyVersion,

382 > WorkflowTaskScheduledEventId: common.EmptyEventID,

383 > WorkflowTaskStartedEventId: common.EmptyEventID,

384 > WorkflowTaskRequestId: emptyUUID,

385 > WorkflowTaskTimeout: timestamp.DurationFromSeconds(0),

386 > WorkflowTaskAttempt: 1,

387 >

388 > LastCompletedWorkflowTaskStartedEventId: common.EmptyEventID,

389 >

390 > StartTime: timestamppb.New(startTime),

391 > ExecutionTime: timestamppb.New(startTime),

392 > VersionHistories: versionhistory.NewVersionHistories(&historyspb.VersionHistory{}),

393 > ExecutionStats: &persistencespb.ExecutionStats{HistorySize: 0},

394 > SubStateMachinesByType: make(map[string]*persistencespb.StateMachineMap),

395 > }

396 > s.executionInfo.TaskGenerationShardClockTimestamp = shard.CurrentVectorClock().GetClock()

397 > s.approximateSize += s.executionInfo.Size()

398 >

399 > s.executionState = &persistencespb.WorkflowExecutionState{

400 > RunId: runID,

401 >

402 > State: enumsspb.WORKFLOW_EXECUTION_STATE_CREATED,

403 > Status: enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING,

404 > StartTime: timestamppb.New(startTime),

405 > RequestIds: make(map[string]*persistencespb.RequestIDInfo),

406 > }

407 > s.approximateSize += s.executionState.Size()

408 >

409 > s.hBuilder = historybuilder.New(

410 > s.timeSource,

411 > s.shard.GenerateTaskIDs,

412 > s.currentVersion,

413 > common.FirstEventID,

414 > s.bufferEventsInDB,

415 > s.metricsHandler,

416 > s.config.MaximumEventBatchSizeInBytes,

417 > )

418 > s.taskGenerator = GetTaskGeneratorProvider().NewTaskGenerator(shard, s)

419 > s.workflowTaskManager = newWorkflowTaskStateMachine(s, s.metricsHandler)

420 >

421 > s.mustInitHSM()

422 >

423 > // TODO@time-skipping: support time skipping for chasm

424 > if s.config.EnableChasm(namespaceName) {

425 > s.chasmTree = chasm.NewEmptyTree( mutable_state_impl.go

426 > shard.ChasmRegistry(),

427 > shard.GetTimeSource(),

428 > s,

429 > chasm.DefaultPathEncoder,

430 > logger,

431 > shard.GetMetricsHandler().WithTags(metrics.NamespaceTag(namespaceName)),

432 > )

433 > }

434

435 > if s.executionInfo.GetTimeSkippingInfo() != nil { mutable_state_impl.go

436 s.wrapTimeSourceWithTimeSkipping()

437 }

438 > return s mutable_state_impl.go

439 }

440

655 }

656

657 > func (ms *MutableStateImpl) mustInitHSM() { mutable_state_impl.go

658 > if ms.executionInfo.SubStateMachinesByType == nil {

659 ms.executionInfo.SubStateMachinesByType = make(map[string]*persistencespb.StateMachineMap)

660 }

661

662 // Error only occurs if some initialization path forgets to register the workflow state machine.

663 > stateMachineNode, err := hsm.NewRoot(ms.shard.StateMachineRegistry(), StateMachineType, ms, ms.executionInfo.SubStateMachinesByType, ms) mutable_state_impl.go

664 > if err != nil {

665 panic(err)

666 }

667 > ms.stateMachineNode = stateMachineNode mutable_state_impl.go

668 }

669

670 > func (ms *MutableStateImpl) IsWorkflow() bool { mutable_state_impl.go

671 > return ms.chasmTree.ArchetypeID() == chasm.WorkflowArchetypeID

672 > }

673

674 > func (ms *MutableStateImpl) HSM() *hsm.Node { mutable_state_impl.go

675 > return ms.stateMachineNode

676 > }

677

678 > func (ms *MutableStateImpl) ChasmTree() historyi.ChasmTree { mutable_state_impl.go

679 > return ms.chasmTree

680 > }

681

682 // ChasmEnabled returns true if the mutable state has a real chasm tree.

991 }

992

993 > func (ms *MutableStateImpl) GetWorkflowKey() definition.WorkflowKey { mutable_state_impl.go

994 > return definition.NewWorkflowKey(

995 > ms.executionInfo.NamespaceId,

996 > ms.executionInfo.WorkflowId,

997 > ms.executionState.RunId,

998 > )

999 > }

1000

1001 > func (ms *MutableStateImpl) GetCurrentBranchToken() ([]byte, error) { mutable_state_impl.go

1002 > currentVersionHistory, err := versionhistory.GetCurrentVersionHistory(ms.executionInfo.VersionHistories)

1003 > if err != nil {

1004 return nil, err

1005 }

1006 > return currentVersionHistory.GetBranchToken(), nil mutable_state_impl.go

1007 }

1008

1120 }

1121

1122 > func (ms *MutableStateImpl) GetExecutionInfo() *persistencespb.WorkflowExecutionInfo { mutable_state_impl.go

1123 > return ms.executionInfo

1124 > }

1125

1126 > func (ms *MutableStateImpl) GetExecutionState() *persistencespb.WorkflowExecutionState { mutable_state_impl.go

1127 > return ms.executionState

1128 > }

1129

1130 func (ms *MutableStateImpl) FlushBufferedEvents() {

1176 }

1177

1178 > func (ms *MutableStateImpl) GetCurrentVersion() int64 { mutable_state_impl.go

1179 > // TODO: can we always return ms.currentVersion here?

1180 > if ms.executionInfo.VersionHistories != nil {

1181 > return ms.currentVersion

1182 > }

1183

1184 if ms.transitionHistoryEnabled && len(ms.executionInfo.TransitionHistory) != 0 {

1190

1191 // NextTransitionCount implements hsm.NodeBackend.

1192 > func (ms *MutableStateImpl) NextTransitionCount() int64 { mutable_state_impl.go

1193 > if !ms.transitionHistoryEnabled {

1194 return 0

1195 }

1196

1197 > currentVersionedTransition := ms.CurrentVersionedTransition() mutable_state_impl.go

1198 > if currentVersionedTransition == nil {

1199 > // it is possible that this is the first transition and mutable_state_impl.go

1200 > // transition history has not been updated yet.

1201 > return 1

1202 > }

1203 return currentVersionedTransition.TransitionCount + 1

1204 }

1358 }

1359

1360 > func (ms *MutableStateImpl) GetNamespaceEntry() *namespace.Namespace { mutable_state_impl.go

1361 > return ms.namespaceEntry

1362 > }

1363

1364 // AddHistoryEvent adds any history event to this workflow execution.

2340 }

2341

2342 > func (ms *MutableStateImpl) GetPendingActivityInfos() map[int64]*persistencespb.ActivityInfo { mutable_state_impl.go

2343 > return ms.pendingActivityInfoIDs

2344 > }

2345

2346 > func (ms *MutableStateImpl) GetPendingTimerInfos() map[string]*persistencespb.TimerInfo { mutable_state_impl.go

2347 > return ms.pendingTimerInfoIDs

2348 > }

2349

2350 func (ms *MutableStateImpl) GetPendingChildExecutionInfos() map[int64]*persistencespb.ChildExecutionInfo {

2384 }

2385

2386 > func (ms *MutableStateImpl) HasStartedWorkflowTask() bool { mutable_state_impl.go

2387 > return ms.workflowTaskManager.HasStartedWorkflowTask()

2388 > }

2389

2390 func (ms *MutableStateImpl) GetStartedWorkflowTask() *historyi.WorkflowTaskInfo {

2469

2470 // GetNextEventID returns next event ID

2471 > func (ms *MutableStateImpl) GetNextEventID() int64 { mutable_state_impl.go

2472 > return ms.hBuilder.NextEventID()

2473 > }

2474

2475 // GetStartedEventIdForLastCompletedWorkflowTask returns last started workflow task event ID

2478 }

2479

2480 > func (ms *MutableStateImpl) IsWorkflowExecutionRunning() bool { mutable_state_impl.go

2481 > switch ms.executionState.State {

2482 > case enumsspb.WORKFLOW_EXECUTION_STATE_CREATED: mutable_state_impl.go

2483 > return true

2484 > case enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING: mutable_state_impl.go

2485 > return true

2486 case enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED:

2487 return false

2580 eventType enumspb.EventType,

2581 eventID int64,

2582 > ) { mutable_state_impl.go

2583 > ms.approximateSize -= ms.executionState.Size()

2584 > if ms.executionState.RequestIds == nil {

2585 ms.executionState.RequestIds = make(map[string]*persistencespb.RequestIDInfo, 1)

2586 }

2587 > ms.executionState.RequestIds[requestID] = &persistencespb.RequestIDInfo{ mutable_state_impl.go

2588 > EventType: eventType,

2589 > EventId: eventID,

2590 > }

2591 > if eventType == enumspb.EVENT_TYPE_WORKFLOW_EXECUTION_STARTED {

2592 > ms.executionState.CreateRequestId = requestID

2593 > }

2594 > ms.approximateSize += ms.executionState.Size()

2595 }

2596

7306 }

7307

7308 > func (ms *MutableStateImpl) DeleteCHASMPureTasks(maxScheduledTime time.Time) { mutable_state_impl.go

7309 > for lastTaskIdx := len(ms.chasmPureTasks) - 1; lastTaskIdx >= 0; lastTaskIdx-- {

7310 task := ms.chasmPureTasks[lastTaskIdx]

7311 if !task.GetVisibilityTime().Before(maxScheduledTime) {

7322 // If we reach here, all tasks have visibility time before maxScheduledTime

7323 // and need to be deleted.

7324 > ms.chasmPureTasks = ms.chasmPureTasks[:0] mutable_state_impl.go

7325 }

7326

7391 state enumsspb.WorkflowExecutionState,

7392 status enumspb.WorkflowExecutionStatus,

7393 > ) (bool, error) { mutable_state_impl.go

7394 > if state == ms.executionState.State && status == ms.executionState.Status {

7395 return false, nil

7396 }

7397 > if state != enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE && mutable_state_impl.go

7398 > ms.executionState.State != enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE {

7399 > // Suppress and Revive workflows are cluster local operations. mutable_state_impl.go

7400 > ms.executionStateUpdated = true

7401 > ms.visibilityUpdated = true // workflow status & state change triggers visibility change as well

7402 > }

7403 > return true, setStateStatus(ms.executionState, state, status) mutable_state_impl.go

7404 }

7405

7416 // isStateDirty is used upon closing transaction to determine if application data has been updated, and

7417 // mutable state should move to a new versioned transition.

7418 > func (ms *MutableStateImpl) isStateDirty() bool { mutable_state_impl.go

7419 > // TODO: we need to track more workflow state changes

7420 > // e.g. changes to executionInfo.CancelRequested

7421 > // They are mostly covered by history builder check today.

7422 > return ms.hBuilder.IsDirty() ||

7423 > len(ms.activityInfosUserDataUpdated) > 0 ||

7424 > len(ms.deleteActivityInfos) > 0 ||

7425 > len(ms.timerInfosUserDataUpdated) > 0 ||

7426 > len(ms.deleteTimerInfos) > 0 ||

7427 > len(ms.updateChildExecutionInfos) > 0 ||

7428 > len(ms.deleteChildExecutionInfos) > 0 ||

7429 > len(ms.updateRequestCancelInfos) > 0 ||

7430 > len(ms.deleteRequestCancelInfos) > 0 ||

7431 > len(ms.updateSignalInfos) > 0 ||

7432 > len(ms.deleteSignalInfos) > 0 ||

7433 > len(ms.updateSignalRequestedIDs) > 0 ||

7434 > len(ms.deleteSignalRequestedIDs) > 0 ||

7435 > len(ms.updateInfoUpdated) > 0 ||

7436 > ms.visibilityUpdated ||

7437 > ms.executionStateUpdated ||

7438 > ms.workflowTaskUpdated ||

7439 > (ms.stateMachineNode != nil && ms.stateMachineNode.Dirty()) ||

7440 > ms.chasmTree.IsStateDirty() ||

7441 > ms.isResetStateUpdated ||

7442 > ms.timeSkippingInfoUpdated

7443 > }

7444

7445 func (ms *MutableStateImpl) IsTransitionHistoryEnabled() bool {

7536 ctx context.Context,

7537 transactionPolicy historyi.TransactionPolicy,

7538 > ) (*persistence.WorkflowSnapshot, []*persistence.WorkflowEvents, error) { mutable_state_impl.go

7539 > result, err := ms.closeTransaction(ctx, transactionPolicy)

7540 > if err != nil {

7541 return nil, nil, err

7542 }

7543

7544 > if len(result.bufferEvents) > 0 { mutable_state_impl.go

7545 // TODO do we need the functionality to generate snapshot with buffered events?

7546 return nil, nil, softassert.UnexpectedInternalErr(

7551 }

7552

7553 > workflowSnapshot := &persistence.WorkflowSnapshot{ mutable_state_impl.go

7554 > ExecutionInfo: ms.executionInfo,

7555 > ExecutionState: ms.executionState,

7556 > NextEventID: ms.hBuilder.NextEventID(),

7557 >

7558 > ActivityInfos: ms.pendingActivityInfoIDs,

7559 > TimerInfos: ms.pendingTimerInfoIDs,

7560 > ChildExecutionInfos: ms.pendingChildExecutionInfoIDs,

7561 > RequestCancelInfos: ms.pendingRequestCancelInfoIDs,

7562 > SignalInfos: ms.pendingSignalInfoIDs,

7563 > SignalRequestedIDs: ms.pendingSignalRequestedIDs,

7564 > ChasmNodes: ms.chasmTree.Snapshot(nil).Nodes,

7565 >

7566 > Tasks: ms.InsertTasks,

7567 >

7568 > Condition: ms.nextEventIDInDB,

7569 > DBRecordVersion: ms.dbRecordVersion,

7570 > Checksum: result.checksum,

7571 > }

7572 >

7573 > ms.checksum = result.checksum

7574 > if err := ms.cleanupTransaction(); err != nil {

7575 return nil, nil, err

7576 }

7577 > return workflowSnapshot, result.workflowEventsSeq, nil mutable_state_impl.go

7578 }

7579

7628 func (ms *MutableStateImpl) SetContextMetadata(

7629 ctx context.Context,

7630 > ) { mutable_state_impl.go

7631 > switch ms.chasmTree.ArchetypeID() {

7632 case chasm.WorkflowArchetypeID, chasm.UnspecifiedArchetypeID:

7633 // Set workflow type

7652 }

7653 }

7654 > default: mutable_state_impl.go

7655 // No metadata to set for other archetype types

7656 }

7660 ctx context.Context,

7661 transactionPolicy historyi.TransactionPolicy,

7662 > ) (closeTransactionResult, error) { mutable_state_impl.go

7663 > ms.SetContextMetadata(ctx)

7664 >

7665 > if err := ms.closeTransactionWithPolicyCheck(

7666 > transactionPolicy,

7667 > ); err != nil {

7668 return closeTransactionResult{}, err

7669 }

7670

7671 > if err := ms.closeTransactionHandleWorkflowTask( mutable_state_impl.go

7672 > transactionPolicy,

7673 > ); err != nil {

7674 return closeTransactionResult{}, err

7675 }

7681 // and need to reconsider the sequence of time skipping close trx handling in this function

7682 // when supporting chasm.

7683 > regenTimerTasksForWorkflowTimeSkipping := ms.closeTransactionHandleWorkflowTimeSkipping(ctx, transactionPolicy) mutable_state_impl.go

7684 >

7685 > // Save if the state is dirty before closeTransactionPrepareEvents since it flushes the buffer

7686 > // events, and therefore change the dirty state.

7687 > isStateDirty := ms.isStateDirty()

7688 >

7689 > // closeTransactionPrepareEvents must be called after closeTransactionHandleWorkflowTask because

7690 > // the latter might fail the workflow task and buffered events must be flushed afterwards.

7691 > // We need to save the value of ms.isStateDirty() before calling closeTransactionPrepareEvents

7692 > // because flushing the buffered events might change the dirty state.

7693 > workflowEventsSeq, eventBatches, bufferEvents, clearBuffer, err := ms.closeTransactionPrepareEvents(transactionPolicy)

7694 > if err != nil {

7695 return closeTransactionResult{}, err

7696 }

7699 // cluster — standby (passive) replays events that were already stamped by

7700 // the active side, and we must not overwrite those principals.

7701 > if transactionPolicy == historyi.TransactionPolicyActive { mutable_state_impl.go

7702 > principal := headers.GetPrincipal(ctx) mutable_state_impl.go

7703 > for _, we := range workflowEventsSeq {

7704 for _, event := range we.Events {

7705 // Skip events that already have a principal. Those are previously

7712 }

7713 }

7714 > for _, event := range bufferEvents { mutable_state_impl.go

7715 event.Principal = principal

7716 }

7719 // CloseTransaction() on chasmTree may update execution state & status,

7720 // so must be called before closeTransactionUpdateTransitionHistory().

7721 > chasmNodesMutation, err := ms.chasmTree.CloseTransaction() mutable_state_impl.go

7722 > if err != nil {

7723 return closeTransactionResult{}, err

7724 }

7725

7726 > if ms.closeTransactionShouldSkipPersistence(isStateDirty, chasmNodesMutation) { mutable_state_impl.go

7727 return closeTransactionResult{

7728 skipPersistence: true,

7730 }

7731

7732 > for nodePath := range chasmNodesMutation.DeletedNodes { mutable_state_impl.go

7733 ms.approximateSize -= ms.chasmNodeSizes[nodePath]

7734 delete(ms.chasmNodeSizes, nodePath)

7735 }

7736 > for nodePath, node := range chasmNodesMutation.UpdatedNodes { mutable_state_impl.go

7737 > newSize := len(nodePath) + node.Size() mutable_state_impl.go

7738 > ms.approximateSize += newSize - ms.chasmNodeSizes[nodePath]

7739 > ms.chasmNodeSizes[nodePath] = newSize

7740 > }

7741

7742 > if isStateDirty { mutable_state_impl.go

7743 > if err := ms.closeTransactionUpdateTransitionHistory( mutable_state_impl.go

7744 > transactionPolicy,

7745 > ); err != nil {

7746 return closeTransactionResult{}, err

7747 }

7748 > ms.closeTransactionHandleUnknownVersionedTransition() mutable_state_impl.go

7749 > ms.closeTransactionUpdateLastRunningClock(transactionPolicy, workflowEventsSeq)

7750 }

7751

7752 // todo@TimeSkipping, we can move update versioned transition to inside closeTransactionHandleWorkflowTimeSkipping

7753 > ms.closeTransactionTrackLastUpdateVersionedTransition( mutable_state_impl.go

7754 > transactionPolicy,

7755 > )

7756 >

7757 > ms.closeTransactionTrackTombstones(transactionPolicy, chasmNodesMutation)

7758 >

7759 > // generate tasks

7760 > if err := ms.closeTransactionPrepareTasks(

7761 > transactionPolicy,

7762 > eventBatches,

7763 > clearBuffer,

7764 > regenTimerTasksForWorkflowTimeSkipping,

7765 > ); err != nil {

7766 return closeTransactionResult{}, err

7767 }

7768

7769 > ms.executionInfo.StateTransitionCount += 1 mutable_state_impl.go

7770 > ms.executionInfo.LastUpdateTime = timestamppb.New(ms.timeSource.Now())

7771 >

7772 > // We generate checksum here based on the assumption that the returned

7773 > // snapshot object is considered immutable. As of this writing, the only

7774 > // code that modifies the returned object lives inside Context.resetWorkflowExecution.

7775 > // Currently, the updates done inside Context.resetWorkflowExecution don't

7776 > // impact the checksum calculation.

7777 > checksum := ms.generateChecksum()

7778 >

7779 > if ms.dbRecordVersion == 0 {

7780 // noop, existing behavior

7781 > } else { mutable_state_impl.go

7782 > ms.dbRecordVersion += 1 mutable_state_impl.go

7783 > }

7784

7785 > return closeTransactionResult{ mutable_state_impl.go

7786 > workflowEventsSeq: workflowEventsSeq,

7787 > bufferEvents: bufferEvents,

7788 > clearBuffer: clearBuffer,

7789 > checksum: checksum,

7790 > chasmNodesMutation: chasmNodesMutation,

7791 > }, nil

7792 }

7793

7794 > func (ms *MutableStateImpl) closeTransactionShouldSkipPersistence(isStateDirty bool, chasmNodesMutation chasm.NodesMutation) bool { mutable_state_impl.go

7795 > return !ms.IsWorkflow() && !isStateDirty && chasmNodesMutation.IsEmpty()

7796 > }

7797

7798 func (ms *MutableStateImpl) closeTransactionHandleWorkflowTask(

7799 transactionPolicy historyi.TransactionPolicy,

7800 > ) error { mutable_state_impl.go

7801 > if err := ms.closeTransactionHandleBufferedEventsLimit(

7802 > transactionPolicy,

7803 > ); err != nil {

7804 return err

7805 }

7806

7807 > if err := ms.closeTransactionHandleWorkflowTaskScheduling( mutable_state_impl.go

7808 > transactionPolicy,

7809 > ); err != nil {

7810 return err

7811 }

7812

7813 > return ms.closeTransactionHandleSpeculativeWorkflowTask(transactionPolicy) mutable_state_impl.go

7814 }

7815

7816 func (ms *MutableStateImpl) closeTransactionHandleWorkflowTaskScheduling(

7817 transactionPolicy historyi.TransactionPolicy,

7818 > ) error { mutable_state_impl.go

7819 > if transactionPolicy == historyi.TransactionPolicyPassive ||

7820 > !ms.IsWorkflowExecutionRunning() {

7821 return nil

7822 }

7823

7824 > for _, t := range ms.currentTransactionAddedStateMachineEventTypes { mutable_state_impl.go

7825 def, ok := ms.shard.StateMachineRegistry().EventDefinition(t)

7826 if !ok {

7840 }

7841

7842 > return nil mutable_state_impl.go

7843 }

7844

7845 func (ms *MutableStateImpl) closeTransactionHandleSpeculativeWorkflowTask(

7846 transactionPolicy historyi.TransactionPolicy,

7847 > ) error { mutable_state_impl.go

7848 > if transactionPolicy == historyi.TransactionPolicyPassive ||

7849 > !ms.IsWorkflowExecutionRunning() {

7850 return nil

7851 }

7854 // because prepareEventsAndReplicationTasks will move internal buffered events to the history,

7855 // and WT related events (WTScheduled, in particular) need to go first.

7856 > return ms.workflowTaskManager.convertSpeculativeWorkflowTaskToNormal() mutable_state_impl.go

7857 }

7858

7859 func (ms *MutableStateImpl) closeTransactionUpdateTransitionHistory(

7860 transactionPolicy historyi.TransactionPolicy,

7861 > ) error { mutable_state_impl.go

7862 > if transactionPolicy != historyi.TransactionPolicyActive {

7863 // TODO: replication/standby logic will need a different way for updating transition history

7864 // when not syncing mutable state

7866 }

7867

7868 > if !ms.transitionHistoryEnabled { mutable_state_impl.go

7869 return nil

7870 }

7871

7872 // handle disable then re-enable of transition history

7873 > if len(ms.executionInfo.TransitionHistory) == 0 && len(ms.executionInfo.PreviousTransitionHistory) != 0 { mutable_state_impl.go

7874 ms.executionInfo.TransitionHistory = ms.executionInfo.PreviousTransitionHistory

7875 ms.executionInfo.PreviousTransitionHistory = nil

7876 }

7877

7878 > ms.executionInfo.TransitionHistory = UpdatedTransitionHistory( mutable_state_impl.go

7879 > ms.executionInfo.TransitionHistory,

7880 > ms.GetCurrentVersion(),

7881 > )

7882 >

7883 > return nil

7884 }

7885

7886 func (ms *MutableStateImpl) closeTransactionTrackLastUpdateVersionedTransition(

7887 transactionPolicy historyi.TransactionPolicy,

7888 > ) { mutable_state_impl.go

7889 > if transactionPolicy != historyi.TransactionPolicyActive {

7890 // TODO: replication/standby logic will need a different way for updating LastUpdatedVersionedTransition

7891 // when reapplying history, especially when history replication tasks got batched.

7893 }

7894

7895 > if !ms.transitionHistoryEnabled { mutable_state_impl.go

7896 // transition history is not enabled

7897 return

7898 }

7899 // transaction closed without any state change

7900 > if len(ms.executionInfo.TransitionHistory) == 0 { mutable_state_impl.go

7901 return

7902 }

7903

7904 > currentVersionedTransition := ms.CurrentVersionedTransition() mutable_state_impl.go

7905 > for activityId := range ms.activityInfosUserDataUpdated {

7906 ms.updateActivityInfos[activityId].LastUpdateVersionedTransition = currentVersionedTransition

7907 }

7908 > for timerId := range ms.timerInfosUserDataUpdated { mutable_state_impl.go

7909 ms.updateTimerInfos[timerId].LastUpdateVersionedTransition = currentVersionedTransition

7910 }

7911 > for _, childInfo := range ms.updateChildExecutionInfos { mutable_state_impl.go

7912 childInfo.LastUpdateVersionedTransition = currentVersionedTransition

7913 }

7914 > for _, cancelInfo := range ms.updateRequestCancelInfos { mutable_state_impl.go

7915 cancelInfo.LastUpdateVersionedTransition = currentVersionedTransition

7916 }

7917 > for _, signalInfo := range ms.updateSignalInfos { mutable_state_impl.go

7918 signalInfo.LastUpdateVersionedTransition = currentVersionedTransition

7919 }

7922 // signal requestedID.

7923 // Deletion of signalRequestID is not replicated today, so we can even drop the check on deleteSignalRequestedIDs

7924 > if len(ms.updateSignalRequestedIDs) != 0 || len(ms.deleteSignalRequestedIDs) != 0 { mutable_state_impl.go

7925 ms.executionInfo.SignalRequestIdsLastUpdateVersionedTransition = currentVersionedTransition

7926 }

7927

7928 > for updateID := range ms.updateInfoUpdated { mutable_state_impl.go

7929 ms.executionInfo.UpdateInfos[updateID].LastUpdateVersionedTransition = currentVersionedTransition

7930 }

7931

7932 > if ms.workflowTaskUpdated { mutable_state_impl.go

7933 ms.executionInfo.WorkflowTaskLastUpdateVersionedTransition = currentVersionedTransition

7934 }

7935

7936 > if ms.visibilityUpdated { mutable_state_impl.go

7937 > ms.executionInfo.VisibilityLastUpdateVersionedTransition = currentVersionedTransition mutable_state_impl.go

7938 > }

7939

7940 > if ms.executionStateUpdated { mutable_state_impl.go

7941 > ms.executionState.LastUpdateVersionedTransition = currentVersionedTransition mutable_state_impl.go

7942 > }

7943

7944 > if ms.timeSkippingInfoUpdated && ms.executionInfo.TimeSkippingInfo != nil { mutable_state_impl.go

7945 ms.executionInfo.TimeSkippingInfo.LastUpdateVersionedTransition = currentVersionedTransition

7946 }

7950 }

7951

7952 > func (ms *MutableStateImpl) closeTransactionHandleUnknownVersionedTransition() { mutable_state_impl.go

7953 > if len(ms.executionInfo.TransitionHistory) != 0 {

7954 > if transitionhistory.Compare( mutable_state_impl.go

7955 > ms.versionedTransitionInDB,

7956 > ms.CurrentVersionedTransition(),

7957 > ) != 0 {

7958 > // versioned transition updated in the transaction

7959 > return

7960 > }

7961 }

7962

8017 transactionPolicy historyi.TransactionPolicy,

8018 workflowEventsSeq []*persistence.WorkflowEvents,

8019 > ) { mutable_state_impl.go

8020 > if transactionPolicy != historyi.TransactionPolicyActive {

8021 return

8022 }

8024 // Events can only be generated while mutable state is running,

8025 // so we can update LastRunningClock blindly.

8026 > if len(workflowEventsSeq) > 0 { mutable_state_impl.go

8027 lastEvents := workflowEventsSeq[len(workflowEventsSeq)-1].Events

8028 lastEvent := lastEvents[len(lastEvents)-1]

8031 }

8032

8033 > if !ms.IsWorkflowExecutionRunning() && !ms.IsCurrentWorkflowGuaranteed() { mutable_state_impl.go

8034 // If workflow currently is not running and also not running at the beginning of the transaction,

8035 // then don't update the lastRunningClock

8038 }

8039

8040 > ms.executionInfo.LastRunningClock = ms.shard.CurrentVectorClock().GetClock() mutable_state_impl.go

8041 }

8042

8044 transactionPolicy historyi.TransactionPolicy,

8045 chasmNodesMutation chasm.NodesMutation,

8046 > ) { mutable_state_impl.go

8047 > if transactionPolicy != historyi.TransactionPolicyActive {

8048 // Passive/Replication logic will update tombstone list when applying mutable state

8049 // snapshot or mutation.

8051 }

8052

8053 > if !ms.transitionHistoryEnabled { mutable_state_impl.go

8054 // transition history is not enabled

8055 return

8056 }

8057

8058 > if len(ms.executionInfo.TransitionHistory) == 0 { mutable_state_impl.go

8059 // in an unknown state

8060 return

8061 }

8062

8063 > var tombstones []*persistencespb.StateMachineTombstone mutable_state_impl.go

8064 > if ms.stateMachineNode != nil {

8065 > opLog, err := ms.stateMachineNode.OpLog()

8066 > if err != nil {

8067 panic(fmt.Sprintf("Failed to get HSM operation log: %v", err))

8068 }

8069

8070 > for _, op := range opLog { mutable_state_impl.go

8071 if deleteOp, ok := op.(hsm.DeleteOperation); ok {

8072 path := deleteOp.Path()

8095 }

8096

8097 > for scheduledEventID := range ms.deleteActivityInfos { mutable_state_impl.go

8098 tombstones = append(tombstones, &persistencespb.StateMachineTombstone{

8099 StateMachineKey: &persistencespb.StateMachineTombstone_ActivityScheduledEventId{

8102 })

8103 }

8104 > for timerID := range ms.deleteTimerInfos { mutable_state_impl.go

8105 tombstones = append(tombstones, &persistencespb.StateMachineTombstone{

8106 StateMachineKey: &persistencespb.StateMachineTombstone_TimerId{

8109 })

8110 }

8111 > for initiatedEventId := range ms.deleteChildExecutionInfos { mutable_state_impl.go

8112 tombstones = append(tombstones, &persistencespb.StateMachineTombstone{

8113 StateMachineKey: &persistencespb.StateMachineTombstone_ChildExecutionInitiatedEventId{

8116 })

8117 }

8118 > for initiatedEventId := range ms.deleteRequestCancelInfos { mutable_state_impl.go

8119 tombstones = append(tombstones, &persistencespb.StateMachineTombstone{

8120 StateMachineKey: &persistencespb.StateMachineTombstone_RequestCancelInitiatedEventId{

8123 })

8124 }

8125 > for initiatedEventId := range ms.deleteSignalInfos { mutable_state_impl.go

8126 tombstones = append(tombstones, &persistencespb.StateMachineTombstone{

8127 StateMachineKey: &persistencespb.StateMachineTombstone_SignalExternalInitiatedEventId{

8130 })

8131 }

8132 > for chasmNodePath := range chasmNodesMutation.DeletedNodes { mutable_state_impl.go

8133 tombstones = append(tombstones, &persistencespb.StateMachineTombstone{

8134 StateMachineKey: &persistencespb.StateMachineTombstone_ChasmNodePath{

8142 // which is not supported by today's DB schema.

8143 // TODO: we don't delete updateInfo today. Track them here when we do.

8144 > currentVersionedTransition := ms.CurrentVersionedTransition() mutable_state_impl.go

8145 >

8146 > tombstoneBatch := &persistencespb.StateMachineTombstoneBatch{

8147 > VersionedTransition: currentVersionedTransition,

8148 > StateMachineTombstones: tombstones,

8149 > }

8150 > // As an optimization, we only track the first empty tombstone batch. So we can know the start point of the tombstone batch

8151 > if len(tombstones) > 0 || len(ms.executionInfo.SubStateMachineTombstoneBatches) == 0 {

8152 > ms.executionInfo.SubStateMachineTombstoneBatches = append(ms.executionInfo.SubStateMachineTombstoneBatches, tombstoneBatch)

8153 > }

8154

8155 > ms.totalTombstones += len(tombstones) mutable_state_impl.go

8156 > ms.capTombstoneCount()

8157 }

8158

8159 // capTombstoneCount limits the total number of tombstones stored in the mutable state.

8160 // This method should be called whenever tombstone batch list is updated or synced.

8161 > func (ms *MutableStateImpl) capTombstoneCount() { mutable_state_impl.go

8162 > tombstoneCountLimit := ms.config.MutableStateTombstoneCountLimit()

8163 > for ms.totalTombstones > tombstoneCountLimit &&

8164 > len(ms.executionInfo.SubStateMachineTombstoneBatches) > 0 {

8165 ms.totalTombstones -= len(ms.executionInfo.SubStateMachineTombstoneBatches[0].StateMachineTombstones)

8166 ms.executionInfo.SubStateMachineTombstoneBatches = ms.executionInfo.SubStateMachineTombstoneBatches[1:]

8173 clearBufferEvents bool,

8174 regenerateTimerTasksForTimeSkipping bool,

8175 > ) error { mutable_state_impl.go

8176 > if err := ms.closeTransactionHandleWorkflowResetTask(

8177 > transactionPolicy,

8178 > ); err != nil {

8179 return err

8180 }

8181

8182 > if err := ms.taskGenerator.GenerateDirtySubStateMachineTasks(ms.shard.StateMachineRegistry()); err != nil { mutable_state_impl.go

8183 return err

8184 }

8185

8186 > ms.closeTransactionCollapseVisibilityTasks() mutable_state_impl.go

8187 >

8188 > if err := ms.closeTransactionGenerateChasmRetentionTask(transactionPolicy); err != nil {

8189 return err

8190 }

8195 // regardless of how many activity & user timer created

8196 // so the calculation must be at the very end

8197 > if err := ms.closeTransactionHandleActivityUserTimerTasks(transactionPolicy); err != nil { mutable_state_impl.go

8198 return err

8199 }

8200 > if regenerateTimerTasksForTimeSkipping { mutable_state_impl.go

8201 if err := ms.closeTransactionRegenTimerTasksForWorkflowTimeSkipping(transactionPolicy); err != nil {

8202 return err

8204 }

8205

8206 > return ms.closeTransactionPrepareReplicationTasks(transactionPolicy, eventBatches, clearBufferEvents) mutable_state_impl.go

8207 }

8208

8209 func (ms *MutableStateImpl) closeTransactionGenerateChasmRetentionTask(

8210 transactionPolicy historyi.TransactionPolicy,

8211 > ) error { mutable_state_impl.go

8212 >

8213 > if ms.IsWorkflow() ||

8214 > ms.executionState.State != enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED ||

8215 > ms.stateInDB == enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED {

8216 > return nil mutable_state_impl.go

8217 > }

8218

8219 // Generate retention timer for chasm executions if it's currentely completed

8234 eventBatches [][]*historypb.HistoryEvent,

8235 clearBufferEvents bool,

8236 > ) error { mutable_state_impl.go

8237 > var replicationTasks []tasks.Task

8238 > if ms.config.ReplicationMultipleBatches() {

8239 task, err := ms.eventsToReplicationTask(transactionPolicy, eventBatches)

8240 if err != nil {

8242 }

8243 replicationTasks = append(replicationTasks, task...)

8244 > } else { mutable_state_impl.go

8245 > for _, historyEvents := range eventBatches {

8246 task, err := ms.eventsToReplicationTask(transactionPolicy, [][]*historypb.HistoryEvent{historyEvents})

8247 if err != nil {

8251 }

8252 }

8253 > replicationTasks = append(replicationTasks, ms.syncActivityToReplicationTask(transactionPolicy)...) mutable_state_impl.go

8254 > replicationTasks = append(replicationTasks, ms.dirtyHSMToReplicationTask(transactionPolicy, eventBatches, clearBufferEvents)...)

8255 >

8256 > archetypeID := ms.ChasmTree().ArchetypeID()

8257 > isWorkflow := archetypeID == chasm.WorkflowArchetypeID

8258 > if !isWorkflow && len(replicationTasks) != 0 {

8259 return softassert.UnexpectedInternalErr(ms.logger, "chasm execution generated workflow replication tasks", nil)

8260 }

8261

8262 > if ms.transitionHistoryEnabled { mutable_state_impl.go

8263 > switch transactionPolicy { mutable_state_impl.go

8264 > case historyi.TransactionPolicyActive: mutable_state_impl.go

8265 > if ms.generateReplicationTask() {

8266 > now := time.Now().UTC() mutable_state_impl.go

8267 > workflowKey := definition.NewWorkflowKey(

8268 > ms.executionInfo.NamespaceId,

8269 > ms.executionInfo.WorkflowId,

8270 > ms.executionState.RunId,

8271 > )

8272 > firstEventID := common.EmptyEventID

8273 > firstEventVersion := common.EmptyVersion

8274 > nextEventID := common.EmptyEventID

8275 > var lastVersionHistoryItem *historyspb.VersionHistoryItem

8276 > if len(eventBatches) > 0 {

8277 firstEventID = eventBatches[0][0].EventId

8278 firstEventVersion = eventBatches[0][0].Version

8279 lastBatch := eventBatches[len(eventBatches)-1]

8280 nextEventID = lastBatch[len(lastBatch)-1].EventId + 1

8281 > } else { mutable_state_impl.go

8282 > currentHistory, err := versionhistory.GetCurrentVersionHistory(ms.executionInfo.VersionHistories) mutable_state_impl.go

8283 > if err != nil {

8284 return err

8285 }

8286 > if !versionhistory.IsEmptyVersionHistory(currentHistory) { mutable_state_impl.go

8287 item, err := versionhistory.GetLastVersionHistoryItem(currentHistory)

8288 //nolint:revive // max-control-nesting: control flow nesting exceeds 5

8294 }

8295

8296 > currentVersionedTransition := ms.CurrentVersionedTransition() mutable_state_impl.go

8297 > if currentVersionedTransition != nil && transitionhistory.Compare(

8298 > ms.versionedTransitionInDB,

8299 > currentVersionedTransition,

8300 > ) != 0 {

8301 > syncVersionedTransitionTask := &tasks.SyncVersionedTransitionTask{ mutable_state_impl.go

8302 > WorkflowKey: workflowKey,

8303 > VisibilityTimestamp: now,

8304 > ArchetypeID: archetypeID,

8305 > Priority: enumsspb.TASK_PRIORITY_HIGH,

8306 > VersionedTransition: currentVersionedTransition,

8307 > FirstEventID: firstEventID,

8308 > FirstEventVersion: firstEventVersion,

8309 > NextEventID: nextEventID,

8310 > TaskEquivalents: replicationTasks,

8311 > LastVersionHistoryItem: lastVersionHistoryItem,

8312 > }

8313 >

8314 > if ms.dbRecordVersion == 1 {

8315 > syncVersionedTransitionTask.IsFirstTask = true mutable_state_impl.go

8316 > }

8317

8318 // versioned transition updated in the transaction

8319 > ms.InsertTasks[tasks.CategoryReplication] = append( mutable_state_impl.go

8320 > ms.InsertTasks[tasks.CategoryReplication],

8321 > syncVersionedTransitionTask,

8322 > )

8323 }

8324 }

8336 }

8337

8338 > if transactionPolicy == historyi.TransactionPolicyPassive && mutable_state_impl.go

8339 > len(ms.InsertTasks[tasks.CategoryReplication]) > 0 {

8340 return softassert.UnexpectedInternalErr(

8341 ms.logger,

8345 }

8346

8347 > return nil mutable_state_impl.go

8348 }

8349

8350 > func (ms *MutableStateImpl) cleanupTransaction() error { mutable_state_impl.go

8351 > ms.updateActivityInfos = make(map[int64]*persistencespb.ActivityInfo)

8352 > ms.deleteActivityInfos = make(map[int64]struct{})

8353 > ms.syncActivityTasks = make(map[int64]struct{})

8354 >

8355 > ms.updateTimerInfos = make(map[string]*persistencespb.TimerInfo)

8356 > ms.deleteTimerInfos = make(map[string]struct{})

8357 >

8358 > ms.updateChildExecutionInfos = make(map[int64]*persistencespb.ChildExecutionInfo)

8359 > ms.deleteChildExecutionInfos = make(map[int64]struct{})

8360 >

8361 > ms.updateRequestCancelInfos = make(map[int64]*persistencespb.RequestCancelInfo)

8362 > ms.deleteRequestCancelInfos = make(map[int64]struct{})

8363 >

8364 > ms.updateSignalInfos = make(map[int64]*persistencespb.SignalInfo)

8365 > ms.deleteSignalInfos = make(map[int64]struct{})

8366 >

8367 > ms.updateSignalRequestedIDs = make(map[string]struct{})

8368 > ms.deleteSignalRequestedIDs = make(map[string]struct{})

8369 >

8370 > ms.visibilityUpdated = false

8371 > ms.executionStateUpdated = false

8372 > ms.workflowTaskUpdated = false

8373 > ms.isResetStateUpdated = false

8374 > ms.timeSkippingInfoUpdated = false

8375 > ms.updateInfoUpdated = make(map[string]struct{})

8376 > ms.timerInfosUserDataUpdated = make(map[string]struct{})

8377 > ms.activityInfosUserDataUpdated = make(map[int64]struct{})

8378 > ms.reapplyEventsCandidate = nil

8379 > ms.subStateMachineDeleted = false

8380 > ms.replayEventBatchID = common.EmptyEventID

8381 >

8382 > ms.stateInDB = ms.executionState.State

8383 > ms.nextEventIDInDB = ms.GetNextEventID()

8384 > if len(ms.executionInfo.TransitionHistory) != 0 {

8385 > ms.versionedTransitionInDB = ms.CurrentVersionedTransition() mutable_state_impl.go

8386 > } else { mutable_state_impl.go

8387 ms.versionedTransitionInDB = nil

8388 }

8389 // ms.dbRecordVersion remains the same

8390

8391 > ms.hBuilder = historybuilder.New( mutable_state_impl.go

8392 > ms.timeSource,

8393 > ms.shard.GenerateTaskIDs,

8394 > ms.GetCurrentVersion(),

8395 > ms.nextEventIDInDB,

8396 > ms.bufferEventsInDB,

8397 > ms.metricsHandler,

8398 > ms.config.MaximumEventBatchSizeInBytes,

8399 > )

8400 >

8401 > ms.InsertTasks = make(map[tasks.Category][]tasks.Task)

8402 > ms.BestEffortDeleteTasks = make(map[tasks.Category][]tasks.Key)

8403 >

8404 > // Clear outputs for the next transaction.

8405 > ms.stateMachineNode.ClearTransactionState()

8406 > // Clear out transient state machine state.

8407 > ms.currentTransactionAddedStateMachineEventTypes = nil

8408 >

8409 > return nil

8410 }

8411

8412 func (ms *MutableStateImpl) closeTransactionPrepareEvents(

8413 transactionPolicy historyi.TransactionPolicy,

8414 > ) ([]*persistence.WorkflowEvents, [][]*historypb.HistoryEvent, []*historypb.HistoryEvent, bool, error) { mutable_state_impl.go

8415 > currentBranchToken, err := ms.GetCurrentBranchToken()

8416 > if err != nil {

8417 return nil, nil, nil, false, err

8418 }

8419

8420 > historyMutation, err := ms.hBuilder.Finish(!ms.HasStartedWorkflowTask()) mutable_state_impl.go

8421 > if err != nil {

8422 return nil, nil, nil, false, err

8423 }

8424

8425 // TODO @wxing1292 need more refactoring to make the logic clean

8426 > ms.bufferEventsInDB = historyMutation.MemBufferBatch mutable_state_impl.go

8427 > newBufferBatch := historyMutation.DBBufferBatch

8428 > clearBuffer := historyMutation.DBClearBuffer

8429 > newEventsBatches := historyMutation.DBEventsBatches

8430 > ms.updatePendingEventIDs(historyMutation.ScheduledIDToStartedID, historyMutation.RequestIDToEventID)

8431 >

8432 > workflowEventsSeq := make([]*persistence.WorkflowEvents, len(newEventsBatches))

8433 > historyNodeTxnIDs, err := ms.shard.GenerateTaskIDs(len(newEventsBatches))

8434 > if err != nil {

8435 return nil, nil, nil, false, err

8436 }

8437 > for index, eventBatch := range newEventsBatches { mutable_state_impl.go

8438 workflowEventsSeq[index] = &persistence.WorkflowEvents{

8439 NamespaceID: ms.executionInfo.NamespaceId,

8459 }

8460

8461 > if err := ms.validateNoEventsAfterWorkflowFinish( mutable_state_impl.go

8462 > transactionPolicy,

8463 > workflowEventsSeq,

8464 > ); err != nil {

8465 return nil, nil, nil, false, err

8466 }

8467

8468 > if len(workflowEventsSeq) > 0 { mutable_state_impl.go

8469 lastEvents := workflowEventsSeq[len(workflowEventsSeq)-1].Events

8470 lastEvent := lastEvents[len(lastEvents)-1]

8477 }

8478

8479 > return workflowEventsSeq, newEventsBatches, newBufferBatch, clearBuffer, nil mutable_state_impl.go

8480 }

8481

8499 func (ms *MutableStateImpl) syncActivityToReplicationTask(

8500 transactionPolicy historyi.TransactionPolicy,

8501 > ) []tasks.Task { mutable_state_impl.go

8502 > now := time.Now().UTC()

8503 > switch transactionPolicy {

8504 > case historyi.TransactionPolicyActive: mutable_state_impl.go

8505 > if ms.generateReplicationTask() {

8506 > var activityIDs map[int64]struct{} mutable_state_impl.go

8507 > if ms.disablingTransitionHistory() {

8508 activityIDs = make(map[int64]struct{}, len(ms.GetPendingActivityInfos()))

8509 for activityID := range ms.GetPendingActivityInfos() {

8510 activityIDs[activityID] = struct{}{}

8511 }

8512 > } else { mutable_state_impl.go

8513 > activityIDs = ms.syncActivityTasks

8514 > }

8515 > return convertSyncActivityInfos(

8516 > now,

8517 > definition.NewWorkflowKey(

8518 > ms.executionInfo.NamespaceId,

8519 > ms.executionInfo.WorkflowId,

8520 > ms.executionState.RunId,

8521 > ),

8522 > ms.pendingActivityInfoIDs,

8523 > activityIDs,

8524 > nil,

8525 > )

8526 }

8527 return nil

8537 eventBatches [][]*historypb.HistoryEvent,

8538 clearBufferEvents bool,

8539 > ) []tasks.Task { mutable_state_impl.go

8540 > switch transactionPolicy {

8541 > case historyi.TransactionPolicyActive: mutable_state_impl.go

8542 > if !ms.generateReplicationTask() {

8543 return emptyTasks

8544 }

8545

8546 // Skip if there are no HSM children (no outbound tasks to generate)

8547 > if len(ms.HSM().InternalRepr().Children) == 0 { mutable_state_impl.go

8548 > return emptyTasks mutable_state_impl.go

8549 > }

8550

8551 // We also assume that - for the time being - if events were generated in a transaction,

8578 scheduledIDToStartedID map[int64]int64,

8579 requestIDToEventID map[string]int64,

8580 > ) error { mutable_state_impl.go

8581 > for scheduledEventID, startedEventID := range scheduledIDToStartedID {

8582 if activityInfo, ok := ms.GetActivityInfo(scheduledEventID); ok {

8583 activityInfo.StartedEventId = startedEventID

8592 }

8593 }

8594 > if len(requestIDToEventID) > 0 { mutable_state_impl.go

8595 var wf *chasmworkflow.Workflow

8596 var chasmCtx chasm.MutableContext

8615 }

8616 }

8617 > return nil mutable_state_impl.go

8618 }

8619

8646 transactionPolicy historyi.TransactionPolicy,

8647 workflowEventSeq []*persistence.WorkflowEvents,

8648 > ) error { mutable_state_impl.go

8649 > if transactionPolicy == historyi.TransactionPolicyPassive ||

8650 > len(workflowEventSeq) == 0 {

8651 > return nil mutable_state_impl.go

8652 > }

8653

8654 // only do check if workflow is finished

8805 func (ms *MutableStateImpl) closeTransactionWithPolicyCheck(

8806 transactionPolicy historyi.TransactionPolicy,

8807 > ) error { mutable_state_impl.go

8808 > switch transactionPolicy {

8809 > case historyi.TransactionPolicyActive: mutable_state_impl.go

8810 > // Cannot use ms.namespaceEntry.ActiveClusterName() because currentVersion may be updated during this transaction in

8811 > // passive cluster. For example: if passive cluster sees conflict and decided to terminate this workflow. The

8812 > // currentVersion on mutable state would be updated to point to last write version which is current (passive) cluster.

8813 > activeCluster := ms.clusterMetadata.ClusterNameForFailoverVersion(ms.namespaceEntry.IsGlobalNamespace(), ms.GetCurrentVersion())

8814 > currentCluster := ms.clusterMetadata.GetCurrentClusterName()

8815 >

8816 > if activeCluster != currentCluster {

8817 namespaceID := ms.GetExecutionInfo().NamespaceId

8818 return serviceerror.NewNamespaceNotActive(namespaceID, currentCluster, activeCluster)

8819 }

8820 > return nil mutable_state_impl.go

8821 case historyi.TransactionPolicyPassive:

8822 return nil

8826 }

8827

8828 > func (ms *MutableStateImpl) BufferSizeAcceptable() bool { mutable_state_impl.go

8829 > if ms.hBuilder.NumBufferedEvents() > ms.config.MaximumBufferedEventsBatch() {

8830 return false

8831 }

8832

8833 > if ms.hBuilder.SizeInBytesOfBufferedEvents() > ms.config.MaximumBufferedEventsSizeInBytes() { mutable_state_impl.go

8834 return false

8835 }

8836 > return true mutable_state_impl.go

8837 }

8838

8839 func (ms *MutableStateImpl) closeTransactionHandleBufferedEventsLimit(

8840 transactionPolicy historyi.TransactionPolicy,

8841 > ) error { mutable_state_impl.go

8842 > if transactionPolicy == historyi.TransactionPolicyPassive ||

8843 > !ms.IsWorkflowExecutionRunning() {

8844 return nil

8845 }

8846

8847 > if ms.BufferSizeAcceptable() { mutable_state_impl.go

8848 > return nil mutable_state_impl.go

8849 > }

8850

8851 // Handling buffered events size issue

8870 func (ms *MutableStateImpl) closeTransactionHandleWorkflowResetTask(

8871 transactionPolicy historyi.TransactionPolicy,

8872 > ) error { mutable_state_impl.go

8873 > if transactionPolicy == historyi.TransactionPolicyPassive ||

8874 > !ms.IsWorkflowExecutionRunning() {

8875 return nil

8876 }

8877

8878 > namespaceEntry, err := ms.shard.GetNamespaceRegistry().GetNamespaceByID(namespace.ID(ms.executionInfo.NamespaceId)) mutable_state_impl.go

8879 > if err != nil {

8880 return err

8881 }

8882 > if _, pt := FindAutoResetPoint( mutable_state_impl.go

8883 > ms.timeSource,

8884 > namespaceEntry.VerifyBinaryChecksum,

8885 > ms.GetExecutionInfo().AutoResetPoints,

8886 > ); pt != nil {

8887 if err := ms.taskGenerator.GenerateWorkflowResetTasks(); err != nil {

8888 return err

8897 )

8898 }

8899 > return nil mutable_state_impl.go

8900 }

8901

8902 func (ms *MutableStateImpl) closeTransactionHandleActivityUserTimerTasks(

8903 transactionPolicy historyi.TransactionPolicy,

8904 > ) error { mutable_state_impl.go

8905 > switch transactionPolicy {

8906 > case historyi.TransactionPolicyActive: mutable_state_impl.go

8907 > if !ms.IsWorkflowExecutionRunning() {

8908 return nil

8909 }

8910 > if err := ms.taskGenerator.GenerateActivityTimerTasks(); err != nil { mutable_state_impl.go

8911 return err

8912 }

8913 > return ms.taskGenerator.GenerateUserTimerTasks() mutable_state_impl.go

8914 case historyi.TransactionPolicyPassive:

8915 return nil

8923 // Any other task type is preserved in order.

8924 // Eg: [START, UPSERT, TP1, CLOSE, TP2, TP3] -> [TP1, CLOSE, TP2, TP3]

8925 > func (ms *MutableStateImpl) closeTransactionCollapseVisibilityTasks() { mutable_state_impl.go

8926 > visTasks := ms.InsertTasks[tasks.CategoryVisibility]

8927 > if len(visTasks) < 2 {

8928 > return mutable_state_impl.go

8929 > }

8930 var visTaskToKeep tasks.Task

8931 lastIndex := -1

8962 }

8963

8964 > func (ms *MutableStateImpl) generateReplicationTask() bool { mutable_state_impl.go

8965 > return len(ms.namespaceEntry.ClusterNames(ms.GetWorkflowKey().WorkflowID)) > 1

8966 > }

8967

8968 func (ms *MutableStateImpl) checkMutability(

8982 }

8983

8984 > func (ms *MutableStateImpl) generateChecksum() *persistencespb.Checksum { mutable_state_impl.go

8985 > if !ms.shouldGenerateChecksum() {

8986 > return nil

8987 > }

8988 csum, err := generateMutableStateChecksum(ms)

8989 if err != nil {

8994 }

8995

8996 > func (ms *MutableStateImpl) shouldGenerateChecksum() bool { mutable_state_impl.go

8997 > if ms.namespaceEntry == nil {

8998 return false

8999 }

9000 > return rand.Intn(100) < ms.config.MutableStateChecksumGenProbability(ms.namespaceEntry.Name().String()) mutable_state_impl.go

9001 }

9002

9073 }

9074

9075 > func (ms *MutableStateImpl) CurrentVersionedTransition() *persistencespb.VersionedTransition { mutable_state_impl.go

9076 > return transitionhistory.LastVersionedTransition(ms.executionInfo.TransitionHistory)

9077 > }

9078

9079 func (ms *MutableStateImpl) ApplyMutation(

9568 }

9569

9570 > func (ms *MutableStateImpl) disablingTransitionHistory() bool { mutable_state_impl.go

9571 > return ms.versionedTransitionInDB != nil && len(ms.executionInfo.TransitionHistory) == 0

9572 > }

9573

9574 func (ms *MutableStateImpl) InitTransitionHistory() {

go.temporal.io/server/chasm/tree.go 429 covered LOC · 144 ranges

Open complete file

301 logger log.Logger,

302 metricsHandler metrics.Handler,

303 > ) *Node { tree.go

304 > root := newTreeHelper(registry, timeSource, backend, pathEncoder, logger, metricsHandler)

305 >

306 > // If serializedNodes is empty, it means that this new tree.

307 > // Initialize empty serializedNode.

308 > root.initSerializedNode(fieldTypeComponent)

309 > // Default to Workflow archetype as empty tree is created for workflow as well.

310 > root.serializedNode.Metadata.GetComponentAttributes().TypeId = WorkflowArchetypeID

311 > // Although both value and serializedNode.Data are nil, they are considered NOT synced

312 > // because value has no type and serializedNode does.

313 > // deserialize method should set value when called.

314 > root.setValueState(valueStateNeedDeserialize)

315 > return root

316 > }

317

318 func newTreeHelper(

323 logger log.Logger,

324 metricsHandler metrics.Handler,

325 > ) *Node { tree.go

326 > base := &nodeBase{

327 > registry: registry,

328 > timeSource: timeSource,

329 > backend: backend,

330 > pathEncoder: pathEncoder,

331 > logger: logger,

332 > metricsHandler: metricsHandler,

333 >

334 > mutation: NodesMutation{

335 > UpdatedNodes: make(map[string]*persistencespb.ChasmNode),

336 > DeletedNodes: make(map[string]struct{}),

337 > },

338 > systemMutation: NodesMutation{

339 > UpdatedNodes: make(map[string]*persistencespb.ChasmNode),

340 > DeletedNodes: make(map[string]struct{}),

341 > },

342 > newTasks: make(map[any][]taskWithAttributes),

343 > immediatePureTasks: make(map[any][]taskWithAttributes),

344 > pendingRequestLinks: make(map[any]map[string][]*commonpb.Link),

345 > pendingUserMetadata: make(map[any]*sdkpb.UserMetadata),

346 > valueToNode: make(map[any]*Node),

347 > taskValueCache: make(map[*commonpb.DataBlob]reflect.Value),

348 > needsPointerResolution: false,

349 > }

350 >

351 > return newNode(base, nil, "")

352 > }

353

354 func newTreeInitSearchAttributesAndMemo(

377 }

378

379 > func searchAttributeKeyValuesToMap(saSlice []SearchAttributeKeyValue) map[string]VisibilityValue { tree.go

380 > result := make(map[string]VisibilityValue, len(saSlice))

381 > for _, sa := range saSlice {

382 > result[sa.Field] = sa.Value

383 > }

384 > return result

385 }

386

387 func (n *Node) SetRootComponent(

388 rootComponent RootComponent,

389 > ) error { tree.go

390 > root := n.root()

391 > root.setValue(rootComponent)

392 > root.setValueState(valueStateNeedSyncStructure)

393 > if componentID, ok := n.registry.ComponentIDFor(rootComponent); ok {

394 > root.serializedNode.GetMetadata().GetComponentAttributes().TypeId = componentID

395 > }

396 > return root.syncSubComponents()

397 }

398

400 // If the node is a component or data node, the index from node value to node (valueToNode)

401 // is also updated.

402 > func (n *Node) setValue(value any) { tree.go

403 > if !n.isComponent() && !n.isData() {

404 n.value = value

405 return

406 }

407

408 > if n.value != nil { tree.go

409 delete(n.valueToNode, n.value)

410 }

411

412 > n.value = value tree.go

413 >

414 > if value != nil {

415 > n.valueToNode[value] = n

416 > }

417 }

418

419 > func (n *Node) setValueState(state valueState) { tree.go

420 > n.valueState = state

421 > if state >= valueStateNeedSerialize {

422 > n.markSubtreeDirty() tree.go

423 > }

424 }

425

429 // markSubtreeDirty marks this node and its entire lineage (ancestors and descendants)

430 // as dirty so that CloseTransaction knows to validate their tasks.

431 > func (n *Node) markSubtreeDirty() { tree.go

432 > // Propagate upward to ancestors.

433 > for cur := n; cur != nil && !cur.subtreeIsDirty; cur = cur.parent {

434 > cur.subtreeIsDirty = true

435 > }

436 // Propagate downward to descendants.

437 > for _, desc := range n.andAllChildren() { tree.go

438 > desc.subtreeIsDirty = true

439 > }

440 }

441

458 chasmContext Context,

459 ref ComponentRef,

460 > ) (Component, error) { tree.go

461 > // Archetype is already validated before this method is called.

462 > // (when the mutable state is loaded, in chasm engine implementation)

463 >

464 > node, ok := n.findNode(ref.componentPath)

465 > if !ok {

466 return nil, errComponentNotFound

467 }

468

469 > if ref.componentInitialVT != nil && transitionhistory.Compare( tree.go

470 > ref.componentInitialVT,

471 > node.serializedNode.Metadata.InitialVersionedTransition,

472 > ) != 0 {

473 return nil, errComponentNotFound

474 }

475

476 > validationContext := NewContext(chasmContext.goContext(), node) tree.go

477 > if err := node.prepareComponentValue(validationContext); err != nil {

478 return nil, err

479 }

480

481 > componentValue, ok := node.value.(Component) tree.go

482 > if !ok {

483 return nil, softassert.UnexpectedInternalErr(

484 n.logger,

487 }

488

489 > if err := node.validateAccess(validationContext, false); err != nil { tree.go

490 return nil, err

491 }

492

493 > if ref.validationFn != nil { tree.go

494 if err := ref.validationFn(node.root().backend, validationContext, componentValue, node.registry); err != nil {

495 return nil, err

498

499 // prepare component value again using incoming context to mark node as dirty if needed.

500 > if err := node.prepareComponentValue(chasmContext); err != nil { tree.go

501 return nil, err

502 }

503 > return componentValue, nil tree.go

504 }

505

517 // Note: engine mutations on paused components are still accepted (checkPaused=false),

518 // per the current requirement.

519 > func (n *Node) validateAccess(ctx Context, checkPaused bool) error { tree.go

520 > intent := operationIntentFromContext(ctx.goContext())

521 > if intent != OperationIntentProgress {

522 > // Read-only operations are always allowed. tree.go

523 > return nil

524 > }

525

526 // Detached nodes skip ancestor validation entirely.

598 func (n *Node) prepareComponentValue(

599 chasmContext Context,

600 > ) error { tree.go

601 > if n.valueState == valueStateNeedDeserialize {

602 metadata := n.serializedNode.Metadata

603 componentAttr := metadata.GetComponentAttributes()

624 // For now, we assume if a node is accessed with a MutableContext,

625 // its value will be mutated and no longer in sync with the serializedNode.

626 > _, componentCanBeMutated := chasmContext.(MutableContext) tree.go

627 > if componentCanBeMutated {

628 n.setValueState(valueStateNeedSyncStructure)

629 }

630

631 > return nil tree.go

632 }

633

680 }

681

682 > func (n *Node) isComponent() bool { tree.go

683 > return n.serializedNode.GetMetadata().GetComponentAttributes() != nil

684 > }

685

686 func (n *Node) isData() bool {

729 }

730

731 > func (n *Node) valueFields() iter.Seq[fieldInfo] { tree.go

732 > return fieldsOf(reflect.ValueOf(n.value))

733 > }

734

735 func assertStructPointer(t reflect.Type) error {

744 }

745

746 > func (n *Node) initSerializedNode(ft fieldType) { tree.go

747 > switch ft {

748 case fieldTypeData:

749 n.serializedNode = &persistencespb.ChasmNode{

758 },

759 }

760 > case fieldTypeComponent: tree.go

761 > n.serializedNode = &persistencespb.ChasmNode{

762 > Metadata: &persistencespb.ChasmNodeMetadata{

763 > InitialVersionedTransition: &persistencespb.VersionedTransition{

764 > TransitionCount: n.backend.NextTransitionCount(),

765 > NamespaceFailoverVersion: n.backend.GetCurrentVersion(),

766 > },

767 > Attributes: &persistencespb.ChasmNodeMetadata_ComponentAttributes{

768 > ComponentAttributes: &persistencespb.ChasmComponentAttributes{},

769 > },

770 > },

771 > }

772 case fieldTypePointer, fieldTypeDeferredPointer:

773 // A deferred pointer will be resolved to a regular pointer before persistence.

833 // serialize sets or updates serializedValue field of the node n with serialized value.

834 // It sets node's valueState to valueStateSynced and updates LastUpdateVersionedTransition.

835 > func (n *Node) serialize() error { tree.go

836 > switch n.serializedNode.GetMetadata().GetAttributes().(type) {

837 > case *persistencespb.ChasmNodeMetadata_ComponentAttributes: tree.go

838 > return n.serializeComponentNode()

839 case *persistencespb.ChasmNodeMetadata_DataAttributes:

840 return n.serializeDataNode()

852 // LastUpdateVersionedTransition, the skip-if-clean revert logic in

853 // closeTransactionSerializeNodes must be updated accordingly.

854 > func (n *Node) serializeComponentNode() error { tree.go

855 > for field := range n.valueFields() {

856 > if field.err != nil {

857 return field.err

858 }

859

860 > if field.kind != fieldKindData { tree.go

861 continue

862 }

863

864 > var blob *commonpb.DataBlob tree.go

865 > if !field.val.IsNil() {

866 > var err error tree.go

867 > if blob, err = encodeChasmBlob(field.val.Interface().(proto.Message)); err != nil {

868 return err

869 }

870 }

871

872 > n.serializedNode.Data = blob tree.go

873 >

874 > if n.serializedNode.GetMetadata().GetLastUpdateVersionedTransition() == nil {

875 > rc, ok := n.registry.componentFor(n.value) tree.go

876 > if !ok {

877 return softassert.UnexpectedInternalErr(

878 n.logger,

881 }

882 // TypeId mismatch on a brand new node indicates node reassignment.

883 > existingTypeID := n.serializedNode.GetMetadata().GetComponentAttributes().GetTypeId() tree.go

884 > if existingTypeID != 0 && existingTypeID != rc.componentID {

885 return softassert.UnexpectedInternalErr(

886 n.logger,

889 )

890 }

891 > n.serializedNode.GetMetadata().GetComponentAttributes().TypeId = rc.componentID tree.go

892 }

893

894 > n.updateLastUpdateVersionedTransition() tree.go

895 > n.setValueState(valueStateSynced)

896

897 // continue to iterate over fields to validate that there is only one proto field in the component.

898 }

899 > return nil tree.go

900 }

901

915 //

916 // nolint:revive,cognitive-complexity

917 > func (n *Node) syncSubComponents() error { tree.go

918 > if n.valueState < valueStateNeedSyncStructure {

919 > for _, childNode := range n.children { tree.go

920 err := childNode.syncSubComponents()

921 if err != nil {

923 }

924 }

925 > return nil tree.go

926 }

927

928 > childrenToKeep := make(map[string]struct{}) tree.go

929 > for field := range n.valueFields() {

930 > if field.err != nil {

931 return field.err

932 }

933

934 > switch field.kind { tree.go

935 case fieldKindUnspecified:

936 softassert.Fail(n.logger,

937 "field.kind can be unspecified only if err is not nil, and there is a check for it above")

938 > case fieldKindData: tree.go

939 // Nothing to sync.

940 case fieldKindSubField:

1020 }

1021

1022 > err := n.deleteChildren(childrenToKeep) tree.go

1023 > n.setValueState(valueStateNeedSerialize)

1024 >

1025 > return err

1026 }

1027

1214 func (n *Node) deleteChildren(

1215 childrenToKeep map[string]struct{},

1216 > ) error { tree.go

1217 > for childName, childNode := range n.children {

1218 if _, childToKeep := childrenToKeep[childName]; !childToKeep {

1219 if err := childNode.delete(false); err != nil {

1222 }

1223 }

1224 > return nil tree.go

1225 }

1226

1277 }

1278

1279 > func (n *Node) updateLastUpdateVersionedTransition() { tree.go

1280 > if n.serializedNode.GetMetadata().GetLastUpdateVersionedTransition() == nil {

1281 > n.serializedNode.GetMetadata().LastUpdateVersionedTransition = &persistencespb.VersionedTransition{} tree.go

1282 > }

1283 > n.serializedNode.GetMetadata().GetLastUpdateVersionedTransition().TransitionCount = n.backend.NextTransitionCount() tree.go

1284 > n.serializedNode.GetMetadata().GetLastUpdateVersionedTransition().NamespaceFailoverVersion = n.backend.GetCurrentVersion()

1285 }

1286

1560 // reference a component that was never registered as a node are dropped and

1561 // logged at warn level to surface caller misuse.

1562 > func (n *Node) closeTransactionApplyPendingComponentMetadata() error { tree.go

1563 > if len(n.pendingRequestLinks) == 0 && len(n.pendingUserMetadata) == 0 {

1564 > return nil

1565 > }

1566 for _, node := range n.andAllChildren() {

1567 if !node.applyPendingComponentMetadata() {

1663 func (n *Node) Now(

1664 _ Component,

1665 > ) time.Time { tree.go

1666 > // TODO: Now() could be different for components after we support Pause for CHASM components.

1667 > return n.timeSource.Now()

1668 > }

1669

1670 // AddTask implements the CHASM MutableContext interface

1692 // CloseTransaction is used by MutableState to close the transaction and

1693 // track changes made in the current transaction.

1694 > func (n *Node) CloseTransaction() (NodesMutation, error) { tree.go

1695 > defer n.cleanupTransaction()

1696 >

1697 > if err := n.executeImmediatePureTasks(); err != nil {

1698 return NodesMutation{}, err

1699 }

1700

1701 > if err := n.syncSubComponents(); err != nil { tree.go

1702 return NodesMutation{}, err

1703 }

1704

1705 > if n.needsPointerResolution { tree.go

1706 if err := n.resolveDeferredPointers(); err != nil {

1707 return NodesMutation{}, err

1709 }

1710

1711 > nextVersionedTransition := &persistencespb.VersionedTransition{ tree.go

1712 > NamespaceFailoverVersion: n.backend.GetCurrentVersion(),

1713 > TransitionCount: n.backend.NextTransitionCount(),

1714 > }

1715 >

1716 > immutableContext := NewContext(context.TODO(), n)

1717 > rootLifecycleChanged, err := n.closeTransactionHandleRootLifecycleChange(immutableContext)

1718 > if err != nil {

1719 return NodesMutation{}, err

1720 }

1721

1722 > if n.subtreeIsDirty { tree.go

1723 > if err := n.closeTransactionForceUpdateVisibility(immutableContext, rootLifecycleChanged); err != nil { tree.go

1724 return NodesMutation{}, err

1725 }

1726 }

1727

1728 > if err := n.closeTransactionSerializeNodes(); err != nil { tree.go

1729 return NodesMutation{}, err

1730 }

1731

1732 > if err := n.closeTransactionUpdateComponentTasks(nextVersionedTransition); err != nil { tree.go

1733 return NodesMutation{}, err

1734 }

1735

1736 > if err := n.closeTransactionApplyPendingComponentMetadata(); err != nil { tree.go

1737 return NodesMutation{}, err

1738 }

1739

1740 // Both user & system data mutation need to be returned and persisted.

1741 > maps.Copy(n.mutation.UpdatedNodes, n.systemMutation.UpdatedNodes) tree.go

1742 > maps.Copy(n.mutation.DeletedNodes, n.systemMutation.DeletedNodes)

1743 >

1744 > return n.mutation, nil

1745 }

1746

1747 > func (n *Node) executeImmediatePureTasks() error { tree.go

1748 >

1749 > // We must sync structure before running any tasks here because,

1750 > // those tasks might be for a newly created component which doesn't even have a node yet.

1751 > // And we want to make sure we only run tasks for components that are still part of the tree.

1752 > syncStructure := true

1753 > var err error

1754 >

1755 > for len(n.immediatePureTasks) != 0 {

1756 // Create a map in case more immediate pure tasks get

1757 // added while existing ones are executed.

1786 }

1787

1788 > return nil tree.go

1789 }

1790

1791 func (n *Node) closeTransactionHandleRootLifecycleChange(

1792 immutableContext Context,

1793 > ) (bool, error) { tree.go

1794 > if n.backend.IsWorkflow() {

1795 // Workflow manages its lifecycle directly in mutable state.

1796 return false, nil

1797 }

1798

1799 > if n.valueState != valueStateNeedSerialize { tree.go

1800 return false, nil

1801 }

1802

1803 > if n.backend.GetExecutionState().State == enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED { tree.go

1804 // Already in completed state, no need to update lifecycle state.

1805 return false, nil

1806 }

1807

1808 > if n.terminated { tree.go

1809 return n.backend.UpdateWorkflowStateStatus(

1810 enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED,

1813 }

1814

1815 > rootComponent, err := n.Component(immutableContext, ComponentRef{}) tree.go

1816 > if err != nil {

1817 return false, err

1818 }

1819 > lifecycleState := rootComponent.LifecycleState(immutableContext) tree.go

1820 >

1821 > var newState enumsspb.WorkflowExecutionState

1822 > var newStatus enumspb.WorkflowExecutionStatus

1823 > switch lifecycleState {

1824 > case LifecycleStateRunning, LifecycleStatePaused:

1825 > // Paused is an OPEN state; the execution remains RUNNING from the persistence perspective.

1826 > newState = enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING

1827 > newStatus = enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING

1828 case LifecycleStateCompleted:

1829 newState = enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED

1839 }

1840

1841 > return n.backend.UpdateWorkflowStateStatus(newState, newStatus) tree.go

1842 }

1843

1845 immutableContext Context,

1846 rootLifecycleChanged bool,

1847 > ) error { tree.go

1848 > if n.deleteAfterClose {

1849 return nil

1850 }

1851

1852 > if !rootLifecycleChanged && tree.go

1853 > n.backend.GetExecutionState().State == enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED {

1854 return nil

1855 }

1856

1857 > needUpdate := rootLifecycleChanged tree.go

1858 >

1859 > rootComponent, err := n.Component(immutableContext, ComponentRef{})

1860 > if err != nil {

1861 return err

1862 }

1863

1864 > saProvider, ok := rootComponent.(VisibilitySearchAttributesProvider) tree.go

1865 > if ok {

1866 > saSlice := saProvider.SearchAttributes(immutableContext) tree.go

1867 > newSA := searchAttributeKeyValuesToMap(saSlice)

1868 > if !maps.EqualFunc(n.currentSA, newSA, isVisibilityValueEqual) {

1869 > needUpdate = true tree.go

1870 > }

1871 > n.currentSA = newSA tree.go

1872 }

1873

1874 > memoProvider, ok := rootComponent.(VisibilityMemoProvider) tree.go

1875 > if ok {

1876 > newMemo := memoProvider.Memo(immutableContext) tree.go

1877 > if !proto.Equal(n.currentMemo, newMemo) {

1878 > needUpdate = true tree.go

1879 > }

1880 > n.currentMemo = proto.Clone(newMemo) tree.go

1881 }

1882

1883 > if !needUpdate { tree.go

1884 return nil

1885 }

1886

1887 > var visibilityNode *Node tree.go

1888 > for _, child := range n.children {

1889 if !child.isComponent() {

1890 continue

1902 }

1903

1904 > if visibilityNode == nil { tree.go

1905 > return nil tree.go

1906 > }

1907

1908 visComponent, err := visibilityNode.Component(immutableContext, ComponentRef{})

1933 }

1934

1935 > func (n *Node) closeTransactionSerializeNodes() error { tree.go

1936 > for nodePath, node := range n.andAllChildren() {

1937 > if node.valueState > valueStateNeedSerialize {

1938 return serviceerror.NewInternalf("invalid valueState for serializing: %v", node.valueState)

1939 }

1940

1941 > if node.valueState < valueStateNeedSerialize { tree.go

1942 continue

1943 }

1944

1945 > encodedPath, err := node.getEncodedPath() tree.go

1946 > if err != nil {

1947 return err

1948 }

1952 // prevData captures the pre-serialize blob pointer; serialize() allocates a new

1953 // blob, leaving prevData pointing at the original for comparison.

1954 > prevVersionedTransition := common.CloneProto( tree.go

1955 > node.serializedNode.GetMetadata().GetLastUpdateVersionedTransition(),

1956 > )

1957 > skipIfClean := (node.isComponent() || node.isData() || node.isMap()) &&

1958 > prevVersionedTransition != nil &&

1959 > !node.hasNewTransactionSideEffects()

1960 > var prevData *commonpb.DataBlob

1961 > if skipIfClean {

1962 prevData = node.serializedNode.Data

1963 }

1964

1965 > if err := node.serialize(); err != nil { tree.go

1966 return err

1967 }

1968

1969 // Data bytes unchanged: revert the versioned transition bump and skip persistence.

1970 > if skipIfClean && bytes.Equal(prevData.GetData(), node.serializedNode.Data.GetData()) { tree.go

1971 node.serializedNode.GetMetadata().LastUpdateVersionedTransition = prevVersionedTransition

1972 continue

1973 }

1974

1975 > if componentAttr := node.serializedNode.GetMetadata().GetComponentAttributes(); componentAttr != nil && tree.go

1976 > componentAttr.TypeId == visibilityComponentTypeID &&

1977 > len(nodePath) != 1 {

1978 return softassert.UnexpectedInternalErr(

1979 n.logger,

1982 }

1983

1984 > n.mutation.UpdatedNodes[encodedPath] = node.serializedNode tree.go

1985 > // DeletedNodes map is populated when syncing tree structure. However, since we may sync tree structure

1986 > // multiple times in one transaction, if node at the same path was previously deleted, have structure synced,

1987 > // then get re-created, the same encoded path will exists in both UpdatedNodes and DeletedNodes maps.

1988 > //

1989 > // serializeNode only happens once at the end of a transaction, and here we know the node at this encoded path exists,

1990 > // remove it from the DeletedNodes map.

1991 > delete(n.mutation.DeletedNodes, encodedPath)

1992 }

1993

1994 > return nil tree.go

1995 }

1996

1997 func (n *Node) closeTransactionUpdateComponentTasks(

1998 nextVersionedTransition *persistencespb.VersionedTransition,

1999 > ) error { tree.go

2000 > taskOffset := int64(1)

2001 > taskValidationContext := NewContext(newContextWithOperationIntent(context.Background(), OperationIntentProgress), n)

2002 >

2003 > archetypeID := n.ArchetypeID()

2004 >

2005 > var firstPureTask *persistencespb.ChasmComponentAttributes_Task

2006 > var firstPureTaskNode *Node

2007 >

2008 > for nodePath, node := range n.andAllChildren() {

2009 > // no-op if node is not a component

2010 > componentAttr := node.serializedNode.Metadata.GetComponentAttributes()

2011 > if componentAttr == nil {

2012 continue

2013 }

2021 // markSubtreeDirty propagates to both ancestors and descendants at mutation time,

2022 // so we skip validation only for nodes with no dirty node anywhere in their lineage.

2023 > if node.subtreeIsDirty { tree.go

2024 > // Ensure this node's component value is hydrated before cleaning up tasks. tree.go

2025 > if err := node.prepareComponentValue(taskValidationContext); err != nil {

2026 return err

2027 }

2028

2029 > cleanedUp, err := node.closeTransactionCleanupInvalidTasks(taskValidationContext) tree.go

2030 > if err != nil {

2031 return err

2032 }

2033

2034 > if cleanedUp { tree.go

2035 // add the current node to UpdatedNodes map if it's not already there

2036 encodedPath, err := node.getEncodedPath()

2054 // This method is called after the closeTransactionSerializeNodes which sets valueState

2055 // to valueStateSynced.

2056 > if transitionhistory.Compare( tree.go

2057 > node.serializedNode.GetMetadata().LastUpdateVersionedTransition,

2058 > nextVersionedTransition,

2059 > ) == 0 && node.valueState != valueStateNeedDeserialize {

2060 > if err := node.closeTransactionHandleNewTasks( tree.go

2061 > nextVersionedTransition,

2062 > taskValidationContext,

2063 > &taskOffset,

2064 > ); err != nil {

2065 return err

2066 }

2067 }

2068

2069 > sideEffectTasks := componentAttr.GetSideEffectTasks() tree.go

2070 > for idx := len(sideEffectTasks) - 1; idx >= 0; idx-- {

2071 sideEffectTask := sideEffectTasks[idx]

2072 if sideEffectTask.PhysicalTaskStatus == physicalTaskStatusCreated {

2083 // Find the first pure task in the entire tree,

2084 // regardless if the pure task is newly added or existing.

2085 > pureTasks := componentAttr.GetPureTasks() tree.go

2086 > if len(pureTasks) == 0 {

2087 > continue tree.go

2088 }

2089

2101 // task, and that component get deleted by the second task.

2102

2103 > return n.closeTransactionGeneratePhysicalPureTask( tree.go

2104 > firstPureTask,

2105 > firstPureTaskNode,

2106 > archetypeID,

2107 > )

2108 }

2109

2164 func (n *Node) closeTransactionCleanupInvalidTasks(

2165 validateContext Context,

2166 > ) (bool, error) { tree.go

2167 > // Validate existing tasks and remove invalid ones.

2168 > var validationErr error

2169 > cleanedUp := false

2170 > deleteFunc := func(existingTask *persistencespb.ChasmComponentAttributes_Task) bool {

2171 existingTaskInstance, err := n.deserializeComponentTask(existingTask)

2172 if err != nil {

2196 }

2197

2198 > componentAttr := n.serializedNode.Metadata.GetComponentAttributes() tree.go

2199 > componentAttr.SideEffectTasks = slices.DeleteFunc(componentAttr.SideEffectTasks, deleteFunc)

2200 > if validationErr != nil {

2201 return false, validationErr

2202 }

2203 > componentAttr.PureTasks = slices.DeleteFunc(componentAttr.PureTasks, deleteFunc) tree.go

2204 > if validationErr != nil {

2205 return false, validationErr

2206 }

2207 > return cleanedUp, nil tree.go

2208 }

2209

2242 validateContext Context,

2243 taskOffset *int64,

2244 > ) error { tree.go

2245 > newTasks, ok := n.newTasks[n.value]

2246 > if !ok {

2247 > return nil tree.go

2248 > }

2249

2250 componentAttr := n.serializedNode.Metadata.GetComponentAttributes()

2346 firstTaskNode *Node,

2347 archetypeID ArchetypeID,

2348 > ) error { tree.go

2349 > if firstPureTask == nil {

2350 > n.backend.DeleteCHASMPureTasks(tasks.MaximumKey.FireTime) tree.go

2351 > return nil

2352 > }

2353

2354 firstPureTaskScheduledTime := firstPureTask.ScheduledTime.AsTime()

2445 // andAllChildren returns a sequence of all nodes in the tree starting from n, including n itself.

2446 // The sequence is depth-first, pre-order traversal.

2447 > func (n *Node) andAllChildren() iter.Seq2[[]string, *Node] { tree.go

2448 > return func(yield func([]string, *Node) bool) {

2449 > var walk func([]string, *Node) bool

2450 > walk = func(path []string, node *Node) bool {

2451 > if node == nil {

2452 return true

2453 }

2454 > if !yield(path, node) { tree.go

2455 return false

2456 }

2457 > for _, child := range node.children { tree.go

2458 childPath := make([]string, len(path)+1)

2459 copy(childPath, path)

2463 }

2464 }

2465 > return true tree.go

2466 }

2467 > walk(nil, n) tree.go

2468 }

2469 }

2470

2471 > func (n *Node) cleanupTransaction() { tree.go

2472 > n.mutation = NodesMutation{

2473 > UpdatedNodes: make(map[string]*persistencespb.ChasmNode),

2474 > DeletedNodes: make(map[string]struct{}),

2475 > }

2476 >

2477 > // System mutation are most likely to be empty, so we reuse existing ones if possible.

2478 > if len(n.systemMutation.UpdatedNodes) != 0 {

2479 n.systemMutation.UpdatedNodes = make(map[string]*persistencespb.ChasmNode)

2480 }

2481 > if len(n.systemMutation.DeletedNodes) != 0 { tree.go

2482 n.systemMutation.DeletedNodes = make(map[string]struct{})

2483 }

2484

2485 > n.newTasks = make(map[any][]taskWithAttributes) tree.go

2486 > if len(n.immediatePureTasks) != 0 {

2487 // n.immediatePureTasks should already be empty after executeImmediatePureTasks()

2488 // unless there's an error.

2490 }

2491

2492 > if len(n.pendingRequestLinks) != 0 { tree.go

2493 n.pendingRequestLinks = make(map[any]map[string][]*commonpb.Link)

2494 }

2495 > if len(n.pendingUserMetadata) != 0 { tree.go

2496 n.pendingUserMetadata = make(map[any]*sdkpb.UserMetadata)

2497 }

2498

2499 > n.needsPointerResolution = false tree.go

2500 >

2501 > // Reset per-node subtreeIsDirty on all nodes in the tree.

2502 > for _, node := range n.andAllChildren() {

2503 > node.subtreeIsDirty = false

2504 > }

2505 }

2506

2510 func (n *Node) Snapshot(

2511 exclusiveMinVT *persistencespb.VersionedTransition,

2512 > ) NodesSnapshot { tree.go

2513 > if !softassert.That(n.logger, n.parent == nil, "chasm.Snapshot() should only be called on the root node") {

2514 panic(fmt.Sprintf("chasm.Snapshot() called on child node: %+v", n))

2515 }

2517 // TODO: add assertion on IsDirty() once implemented

2518

2519 > nodes := make(map[string]*persistencespb.ChasmNode) tree.go

2520 > n.snapshotInternal(exclusiveMinVT, nodes)

2521 >

2522 > return NodesSnapshot{

2523 > Nodes: nodes,

2524 > }

2525 }

2526

2528 exclusiveMinVT *persistencespb.VersionedTransition,

2529 nodes map[string]*persistencespb.ChasmNode,

2530 > ) { tree.go

2531 > if n == nil {

2532 return

2533 }

2534

2535 > if transitionhistory.Compare(n.serializedNode.Metadata.LastUpdateVersionedTransition, exclusiveMinVT) > 0 { tree.go

2536 > encodedPath, err := n.getEncodedPath() tree.go

2537 > if !softassert.That(n.logger, err == nil, "chasm path encoding should always succeed on clean tree") {

2538 panic(fmt.Sprintf("failed to encode chasm path on clean tree: %v", err))

2539 }

2540 > nodes[encodedPath] = n.serializedNode tree.go

2541 }

2542

2543 > for _, childNode := range n.children { tree.go

2544 childNode.snapshotInternal(

2545 exclusiveMinVT,

2931 }

2932

2933 > func (n *Node) getEncodedPath() (string, error) { tree.go

2934 > if n.encodedPath != nil {

2935 > return *n.encodedPath, nil tree.go

2936 > }

2937 > encodePath, err := n.pathEncoder.Encode(n, n.path()) tree.go

2938 > if err == nil {

2939 > n.encodedPath = &encodePath

2940 > }

2941 > return encodePath, err

2942 }

2943

2944 > func (n *Node) path() []string { tree.go

2945 > if n.parent == nil {

2946 > return []string{}

2947 > }

2948

2949 return append(n.parent.path(), n.nodeName)

2952 func (n *Node) findNode(

2953 path []string,

2954 > ) (*Node, bool) { tree.go

2955 > if len(path) == 0 {

2956 > return n, true

2957 > }

2958

2959 childName := path[0]

3053 // which need to be persisted to DB AND replicated to other clusters.

3054 // The result will be reset to false after a call to CloseTransaction().

3055 > func (n *Node) IsStateDirty() bool { tree.go

3056 > return n.subtreeIsDirty ||

3057 > len(n.mutation.UpdatedNodes) > 0 ||

3058 > len(n.mutation.DeletedNodes) > 0

3059 > }

3060

3061 func (n *Node) IsStale(

3115

3116 // ArchetypeID returns the framework's internal ID for the root component's fully qualified name.

3117 > func (n *Node) ArchetypeID() ArchetypeID { tree.go

3118 > // Root must be a component.

3119 > return n.root().serializedNode.Metadata.GetComponentAttributes().GetTypeId()

3120 > }

3121

3122 // Archetype returns the root component's fully qualified name.

3136 }

3137

3138 > func (n *Node) root() *Node { tree.go

3139 > if n.parent == nil {

3140 > return n

3141 > }

3142 return n.parent.root()

3143 }

3261 parent *Node,

3262 nodeName string,

3263 > ) *Node { tree.go

3264 > return &Node{

3265 > nodeBase: base,

3266 > parent: parent,

3267 > children: make(map[string]*Node),

3268 > nodeName: nodeName,

3269 > }

3270 > }

3271

3272 func compareSideEffectTasks(a, b *persistencespb.ChasmComponentAttributes_Task) int {

3868 // encodeChasmBlob encodes CHASM data and task payloads through the env-aware

3869 // serializer while preserving deterministic proto3 bytes for byte comparisons.

3870 > func encodeChasmBlob(m proto.Message) (*commonpb.DataBlob, error) { tree.go

3871 > return serialization.Encode(m, serialization.WithDeterministicProto3)

3872 > }

go.temporal.io/server/service/history/configs/config.go 392 covered LOC · 1 range

Open complete file

445 dc *dynamicconfig.Collection,

446 numberOfShards int32,

447 > ) *Config { config.go

448 > cfg := &Config{

449 > NumberOfShards: numberOfShards,

450 >

451 > EnableReplicationStream: dynamicconfig.EnableReplicationStream.Get(dc),

452 > EmitReplicationLifecycleEvents: dynamicconfig.EmitReplicationLifecycleEvents.Get(dc),

453 > EnableCloseInboundReplicationStreamOnShutdown: dynamicconfig.EnableCloseInboundReplicationStreamOnShutdown.Get(dc),

454 > EnableSeparateReplicationEnableFlag: dynamicconfig.EnableSeparateReplicationEnableFlag.Get(dc),

455 > HistoryReplicationDLQV2: dynamicconfig.EnableHistoryReplicationDLQV2.Get(dc),

456 >

457 > RPS: dynamicconfig.HistoryRPS.Get(dc),

458 > NamespaceRPS: dynamicconfig.HistoryNamespaceRPS.Get(dc),

459 > OperatorRPSRatio: dynamicconfig.OperatorRPSRatio.Get(dc),

460 > MaxIDLengthLimit: dynamicconfig.MaxIDLengthLimit.Get(dc),

461 > PersistenceMaxQPS: dynamicconfig.HistoryPersistenceMaxQPS.Get(dc),

462 > PersistenceGlobalMaxQPS: dynamicconfig.HistoryPersistenceGlobalMaxQPS.Get(dc),

463 > PersistenceNamespaceMaxQPS: dynamicconfig.HistoryPersistenceNamespaceMaxQPS.Get(dc),

464 > PersistenceGlobalNamespaceMaxQPS: dynamicconfig.HistoryPersistenceGlobalNamespaceMaxQPS.Get(dc),

465 > PersistencePerShardNamespaceMaxQPS: dynamicconfig.HistoryPersistencePerShardNamespaceMaxQPS.Get(dc),

466 > PersistenceDynamicRateLimitingParams: dynamicconfig.HistoryPersistenceDynamicRateLimitingParams.Get(dc),

467 > PersistenceQPSBurstRatio: dynamicconfig.PersistenceQPSBurstRatio.Get(dc),

468 > AlignMembershipChange: dynamicconfig.HistoryAlignMembershipChange.Get(dc),

469 > ShutdownDrainDuration: dynamicconfig.HistoryShutdownDrainDuration.Get(dc),

470 > StartupMembershipJoinDelay: dynamicconfig.HistoryStartupMembershipJoinDelay.Get(dc),

471 > AllowResetWithPendingChildren: dynamicconfig.AllowResetWithPendingChildren.Get(dc),

472 > MaxAutoResetPoints: dynamicconfig.HistoryMaxAutoResetPoints.Get(dc),

473 > DefaultWorkflowTaskTimeout: dynamicconfig.DefaultWorkflowTaskTimeout.Get(dc),

474 >

475 > MaxLocalParentWorkflowVerificationDuration: dynamicconfig.MaxLocalParentWorkflowVerificationDuration.Get(dc),

476 >

477 > VisibilityPersistenceMaxReadQPS: dynamicconfig.VisibilityPersistenceMaxReadQPS.Get(dc),

478 > VisibilityPersistenceMaxWriteQPS: dynamicconfig.VisibilityPersistenceMaxWriteQPS.Get(dc),

479 > VisibilityPersistenceSlowQueryThreshold: dynamicconfig.VisibilityPersistenceSlowQueryThreshold.Get(dc),

480 > EnableReadFromSecondaryVisibility: dynamicconfig.EnableReadFromSecondaryVisibility.Get(dc),

481 > VisibilityEnableShadowReadMode: dynamicconfig.VisibilityEnableShadowReadMode.Get(dc),

482 > SecondaryVisibilityWritingMode: dynamicconfig.SecondaryVisibilityWritingMode.Get(dc),

483 > VisibilityDisableOrderByClause: dynamicconfig.VisibilityDisableOrderByClause.Get(dc),

484 > VisibilityEnableManualPagination: dynamicconfig.VisibilityEnableManualPagination.Get(dc),

485 > VisibilityEnableUnifiedQueryConverter: dynamicconfig.VisibilityEnableUnifiedQueryConverter.Get(dc),

486 > VisibilityAllowList: dynamicconfig.VisibilityAllowList.Get(dc),

487 > SuppressErrorSetSystemSearchAttribute: dynamicconfig.SuppressErrorSetSystemSearchAttribute.Get(dc),

488 >

489 > EmitShardLagLog: dynamicconfig.EmitShardLagLog.Get(dc),

490 > EnableDataLossMetrics: dynamicconfig.EnableDataLossMetrics.Get(dc),

491 > // HistoryCacheLimitSizeBased should not change during runtime.

492 > HistoryCacheLimitSizeBased: dynamicconfig.HistoryCacheSizeBasedLimit.Get(dc)(),

493 > HistoryHostLevelCacheMaxSize: dynamicconfig.HistoryCacheHostLevelMaxSize.Get(dc),

494 > HistoryHostLevelCacheMaxSizeBytes: dynamicconfig.HistoryCacheHostLevelMaxSizeBytes.Get(dc),

495 > HistoryCacheTTL: dynamicconfig.HistoryCacheTTL.Get(dc),

496 > HistoryCacheNonUserContextLockTimeout: dynamicconfig.HistoryCacheNonUserContextLockTimeout.Get(dc),

497 > HistoryCacheBackgroundEvict: dynamicconfig.HistoryCacheBackgroundEvict.Get(dc),

498 > EnableWorkflowExecutionTimeoutTimer: dynamicconfig.EnableWorkflowExecutionTimeoutTimer.Get(dc),

499 > EnableUpdateWorkflowModeIgnoreCurrent: dynamicconfig.EnableUpdateWorkflowModeIgnoreCurrent.Get(dc),

500 > EnableTransitionHistory: dynamicconfig.EnableTransitionHistory.Get(dc),

501 > MaxCallbacksPerWorkflow: dynamicconfig.MaxCallbacksPerWorkflow.Get(dc),

502 > MaxCallbacksPerExecution: callback.MaxPerExecution.Get(dc),

503 > MaxCallbacksPerUpdateID: dynamicconfig.MaxCallbacksPerUpdateID.Get(dc),

504 > EnableChasm: dynamicconfig.EnableChasm.Get(dc),

505 > EnableChasmNexusWorkflowOperations: nexusoperation.EnableChasmWorkflowOperations.Get(dc),

506 > ChasmMaxInMemoryPureTasks: dynamicconfig.ChasmMaxInMemoryPureTasks.Get(dc),

507 >

508 > EnableCHASMSchedulerCreation: dynamicconfig.EnableCHASMSchedulerCreation.Get(dc),

509 > EnableCHASMSchedulerMigration: dynamicconfig.EnableCHASMSchedulerMigration.Get(dc),

510 >

511 > EnableCHASMCallbacks: dynamicconfig.EnableCHASMCallbacks.Get(dc),

512 > EnableCHASMSignalBacklinks: dynamicconfig.EnableCHASMSignalBacklinks.Get(dc),

513 > ExternalPayloadsEnabled: dynamicconfig.ExternalPayloadsEnabled.Get(dc),

514 > EnableWorkflowUpdateCallbacks: dynamicconfig.EnableWorkflowUpdateCallbacks.Get(dc),

515 >

516 > EventsShardLevelCacheMaxSizeBytes: dynamicconfig.EventsCacheMaxSizeBytes.Get(dc), // 512KB

517 > EventsHostLevelCacheMaxSizeBytes: dynamicconfig.EventsHostLevelCacheMaxSizeBytes.Get(dc), // 256MB

518 > EventsCacheTTL: dynamicconfig.EventsCacheTTL.Get(dc),

519 > EnableHostLevelEventsCache: dynamicconfig.EnableHostLevelEventsCache.Get(dc),

520 >

521 > RangeSizeBits: 20, // 20 bits for sequencer, 2^20 sequence number for any range

522 >

523 > AcquireShardInterval: dynamicconfig.AcquireShardInterval.Get(dc),

524 > AcquireShardConcurrency: dynamicconfig.AcquireShardConcurrency.Get(dc),

525 > ShardIOConcurrency: dynamicconfig.ShardIOConcurrency.Get(dc),

526 > ShardIOTimeout: dynamicconfig.ShardIOTimeout.Get(dc),

527 > ShardLingerOwnershipCheckQPS: dynamicconfig.ShardLingerOwnershipCheckQPS.Get(dc),

528 > ShardLingerTimeLimit: dynamicconfig.ShardLingerTimeLimit.Get(dc),

529 > ShardFinalizerTimeout: dynamicconfig.ShardFinalizerTimeout.Get(dc),

530 >

531 > HistoryClientOwnershipCachingEnabled: dynamicconfig.HistoryClientOwnershipCachingEnabled.Get(dc),

532 >

533 > StandbyClusterDelay: dynamicconfig.StandbyClusterDelay.Get(dc),

534 > StandbyTaskMissingEventsResendDelay: dynamicconfig.StandbyTaskMissingEventsResendDelay.Get(dc),

535 > StandbyTaskMissingEventsDiscardDelay: dynamicconfig.StandbyTaskMissingEventsDiscardDelay.Get(dc),

536 > ChasmStandbyTaskDiscardDelay: dynamicconfig.ChasmStandbyTaskDiscardDelay.Get(dc),

537 >

538 > QueuePendingTaskCriticalCount: dynamicconfig.QueuePendingTaskCriticalCount.Get(dc),

539 > QueueReaderStuckCriticalAttempts: dynamicconfig.QueueReaderStuckCriticalAttempts.Get(dc),

540 > QueueCriticalSlicesCount: dynamicconfig.QueueCriticalSlicesCount.Get(dc),

541 > QueuePendingTaskMaxCount: dynamicconfig.QueuePendingTaskMaxCount.Get(dc),

542 > QueueMaxPredicateSize: dynamicconfig.QueueMaxPredicateSize.Get(dc),

543 > QueueShrinkPredicateMaxPendingKeys: dynamicconfig.QueueShrinkPredicateMaxPendingKeys.Get(dc),

544 > QueueMoveGroupTaskCountBase: dynamicconfig.QueueMoveGroupTaskCountBase.Get(dc),

545 > QueueMoveGroupTaskCountMultiplier: dynamicconfig.QueueMoveGroupTaskCountMultiplier.Get(dc),

546 >

547 > TaskDLQEnabled: dynamicconfig.HistoryTaskDLQEnabled.Get(dc),

548 > TaskDLQUnexpectedErrorAttempts: dynamicconfig.HistoryTaskDLQUnexpectedErrorAttempts.Get(dc),

549 > TaskDLQInternalErrors: dynamicconfig.HistoryTaskDLQInternalErrors.Get(dc),

550 > TaskDLQErrorPattern: dynamicconfig.HistoryTaskDLQErrorPattern.Get(dc),

551 >

552 > TaskSchedulerEnableRateLimiter: dynamicconfig.TaskSchedulerEnableRateLimiter.Get(dc),

553 > TaskSchedulerEnableRateLimiterShadowMode: dynamicconfig.TaskSchedulerEnableRateLimiterShadowMode.Get(dc),

554 > TaskSchedulerRateLimiterStartupDelay: dynamicconfig.TaskSchedulerRateLimiterStartupDelay.Get(dc),

555 > TaskSchedulerGlobalMaxQPS: dynamicconfig.TaskSchedulerGlobalMaxQPS.Get(dc),

556 > TaskSchedulerMaxQPS: dynamicconfig.TaskSchedulerMaxQPS.Get(dc),

557 > TaskSchedulerNamespaceMaxQPS: dynamicconfig.TaskSchedulerNamespaceMaxQPS.Get(dc),

558 > TaskSchedulerGlobalNamespaceMaxQPS: dynamicconfig.TaskSchedulerGlobalNamespaceMaxQPS.Get(dc),

559 > TaskSchedulerInactiveChannelDeletionDelay: dynamicconfig.TaskSchedulerInactiveChannelDeletionDelay.Get(dc),

560 > TaskSchedulerEnableExecutionQueueScheduler: dynamicconfig.TaskSchedulerEnableExecutionQueueScheduler.Get(dc),

561 > TaskSchedulerExecutionQueueSchedulerMaxQueues: dynamicconfig.TaskSchedulerExecutionQueueSchedulerMaxQueues.Get(dc),

562 > TaskSchedulerExecutionQueueSchedulerQueueTTL: dynamicconfig.TaskSchedulerExecutionQueueSchedulerQueueTTL.Get(dc),

563 > TaskSchedulerExecutionQueueSchedulerQueueConcurrency: dynamicconfig.TaskSchedulerExecutionQueueSchedulerQueueConcurrency.Get(dc),

564 >

565 > TimerTaskBatchSize: dynamicconfig.TimerTaskBatchSize.Get(dc),

566 > TimerProcessorSchedulerWorkerCount: dynamicconfig.TimerProcessorSchedulerWorkerCount.Subscribe(dc),

567 > TimerProcessorSchedulerActiveRoundRobinWeights: dynamicconfig.TimerProcessorSchedulerActiveRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultActiveTaskPriorityWeight)).Get(dc),

568 > TimerProcessorSchedulerStandbyRoundRobinWeights: dynamicconfig.TimerProcessorSchedulerStandbyRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultStandbyTaskPriorityWeight)).Get(dc),

569 > TimerProcessorUpdateAckInterval: dynamicconfig.TimerProcessorUpdateAckInterval.Get(dc),

570 > TimerProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.TimerProcessorUpdateAckIntervalJitterCoefficient.Get(dc),

571 > TimerProcessorMaxPollRPS: dynamicconfig.TimerProcessorMaxPollRPS.Get(dc),

572 > TimerProcessorMaxPollHostRPS: dynamicconfig.TimerProcessorMaxPollHostRPS.Get(dc),

573 > TimerProcessorMaxPollInterval: dynamicconfig.TimerProcessorMaxPollInterval.Get(dc),

574 > TimerProcessorMaxPollIntervalJitterCoefficient: dynamicconfig.TimerProcessorMaxPollIntervalJitterCoefficient.Get(dc),

575 > TimerProcessorPollBackoffInterval: dynamicconfig.TimerProcessorPollBackoffInterval.Get(dc),

576 > TimerProcessorMaxTimeShift: dynamicconfig.TimerProcessorMaxTimeShift.Get(dc),

577 > TransferQueueMaxReaderCount: dynamicconfig.TransferQueueMaxReaderCount.Get(dc),

578 > RetentionTimerJitterDuration: dynamicconfig.RetentionTimerJitterDuration.Get(dc),

579 >

580 > MemoryTimerProcessorSchedulerWorkerCount: dynamicconfig.MemoryTimerProcessorSchedulerWorkerCount.Subscribe(dc),

581 >

582 > TransferTaskBatchSize: dynamicconfig.TransferTaskBatchSize.Get(dc),

583 > TransferProcessorSchedulerWorkerCount: dynamicconfig.TransferProcessorSchedulerWorkerCount.Subscribe(dc),

584 > TransferProcessorSchedulerActiveRoundRobinWeights: dynamicconfig.TransferProcessorSchedulerActiveRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultActiveTaskPriorityWeight)).Get(dc),

585 > TransferProcessorSchedulerStandbyRoundRobinWeights: dynamicconfig.TransferProcessorSchedulerStandbyRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultStandbyTaskPriorityWeight)).Get(dc),

586 > TransferProcessorMaxPollRPS: dynamicconfig.TransferProcessorMaxPollRPS.Get(dc),

587 > TransferProcessorMaxPollHostRPS: dynamicconfig.TransferProcessorMaxPollHostRPS.Get(dc),

588 > TransferProcessorMaxPollInterval: dynamicconfig.TransferProcessorMaxPollInterval.Get(dc),

589 > TransferProcessorMaxPollIntervalJitterCoefficient: dynamicconfig.TransferProcessorMaxPollIntervalJitterCoefficient.Get(dc),

590 > TransferProcessorUpdateAckInterval: dynamicconfig.TransferProcessorUpdateAckInterval.Get(dc),

591 > TransferProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.TransferProcessorUpdateAckIntervalJitterCoefficient.Get(dc),

592 > TransferProcessorPollBackoffInterval: dynamicconfig.TransferProcessorPollBackoffInterval.Get(dc),

593 > TransferProcessorEnsureCloseBeforeDelete: dynamicconfig.TransferProcessorEnsureCloseBeforeDelete.Get(dc),

594 > TimerQueueMaxReaderCount: dynamicconfig.TimerQueueMaxReaderCount.Get(dc),

595 >

596 > OutboundTaskBatchSize: dynamicconfig.OutboundTaskBatchSize.Get(dc),

597 > OutboundProcessorMaxPollRPS: dynamicconfig.OutboundProcessorMaxPollRPS.Get(dc),

598 > OutboundProcessorMaxPollHostRPS: dynamicconfig.OutboundProcessorMaxPollHostRPS.Get(dc),

599 > OutboundProcessorMaxPollInterval: dynamicconfig.OutboundProcessorMaxPollInterval.Get(dc),

600 > OutboundProcessorMaxPollIntervalJitterCoefficient: dynamicconfig.OutboundProcessorMaxPollIntervalJitterCoefficient.Get(dc),

601 > OutboundProcessorUpdateAckInterval: dynamicconfig.OutboundProcessorUpdateAckInterval.Get(dc),

602 > OutboundProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.OutboundProcessorUpdateAckIntervalJitterCoefficient.Get(dc),

603 > OutboundProcessorPollBackoffInterval: dynamicconfig.OutboundProcessorPollBackoffInterval.Get(dc),

604 > OutboundQueuePendingTaskCriticalCount: dynamicconfig.OutboundQueuePendingTaskCriticalCount.Get(dc),

605 > OutboundQueuePendingTaskMaxCount: dynamicconfig.OutboundQueuePendingTaskMaxCount.Get(dc),

606 > OutboundQueueMaxPredicateSize: dynamicconfig.OutboundQueueMaxPredicateSize.Get(dc),

607 > OutboundQueueMaxReaderCount: dynamicconfig.OutboundQueueMaxReaderCount.Get(dc),

608 > OutboundQueueGroupLimiterBufferSize: dynamicconfig.OutboundQueueGroupLimiterBufferSize.Get(dc),

609 > OutboundQueueGroupLimiterConcurrency: dynamicconfig.OutboundQueueGroupLimiterConcurrency.Get(dc),

610 > OutboundQueueHostSchedulerMaxTaskRPS: dynamicconfig.OutboundQueueHostSchedulerMaxTaskRPS.Get(dc),

611 > OutboundQueueCircuitBreakerSettings: dynamicconfig.OutboundQueueCircuitBreakerSettings.Subscribe(dc),

612 > OutboundStandbyTaskMissingEventsDestinationDownErr: dynamicconfig.OutboundStandbyTaskMissingEventsDestinationDownErr.Get(dc),

613 > OutboundStandbyTaskMissingEventsDiscardDelay: dynamicconfig.OutboundStandbyTaskMissingEventsDiscardDelay.Get(dc),

614 >

615 > ReplicatorProcessorMaxPollInterval: dynamicconfig.ReplicatorProcessorMaxPollInterval.Get(dc),

616 > ReplicatorProcessorMaxPollIntervalJitterCoefficient: dynamicconfig.ReplicatorProcessorMaxPollIntervalJitterCoefficient.Get(dc),

617 > ReplicatorProcessorFetchTasksBatchSize: dynamicconfig.ReplicatorTaskBatchSize.Get(dc),

618 > ReplicatorProcessorMaxSkipTaskCount: dynamicconfig.ReplicatorMaxSkipTaskCount.Get(dc),

619 > ReplicationTaskProcessorHostQPS: dynamicconfig.ReplicationTaskProcessorHostQPS.Get(dc),

620 > ReplicationTaskProcessorShardQPS: dynamicconfig.ReplicationTaskProcessorShardQPS.Get(dc),

621 > ReplicationEnableDLQMetrics: dynamicconfig.ReplicationEnableDLQMetrics.Get(dc),

622 > ReplicationEnableUpdateWithNewTaskMerge: dynamicconfig.ReplicationEnableUpdateWithNewTaskMerge.Get(dc),

623 > ReplicationStreamSyncStatusDuration: dynamicconfig.ReplicationStreamSyncStatusDuration.Get(dc),

624 > ReplicationProcessorSchedulerQueueSize: dynamicconfig.ReplicationProcessorSchedulerQueueSize.Get(dc),

625 > ReplicationProcessorSchedulerWorkerCount: dynamicconfig.ReplicationProcessorSchedulerWorkerCount.Subscribe(dc),

626 > ReplicationLowPriorityProcessorSchedulerWorkerCount: dynamicconfig.ReplicationLowPriorityProcessorSchedulerWorkerCount.Subscribe(dc),

627 > ReplicationLowPriorityTaskParallelism: dynamicconfig.ReplicationLowPriorityTaskParallelism.Get(dc),

628 > EnableReplicationTaskBatching: dynamicconfig.EnableReplicationTaskBatching.Get(dc),

629 > EnableReplicationTaskTieredProcessing: dynamicconfig.EnableReplicationTaskTieredProcessing.Get(dc),

630 > ReplicationStreamSenderHighPriorityQPS: dynamicconfig.ReplicationStreamSenderHighPriorityQPS.Get(dc),

631 > ReplicationStreamSenderLowPriorityQPS: dynamicconfig.ReplicationStreamSenderLowPriorityQPS.Get(dc),

632 > ReplicationStreamEventLoopRetryMaxAttempts: dynamicconfig.ReplicationStreamEventLoopRetryMaxAttempts.Get(dc),

633 > ReplicationReceiverMaxOutstandingTaskCount: dynamicconfig.ReplicationReceiverMaxOutstandingTaskCount.Get(dc),

634 > ReplicationReceiverSlowSubmissionLatencyThreshold: dynamicconfig.ReplicationReceiverSlowSubmissionLatencyThreshold.Get(dc),

635 > ReplicationReceiverSlowSubmissionWindow: dynamicconfig.ReplicationReceiverSlowSubmissionWindow.Get(dc),

636 > EnableReplicationReceiverSlowSubmissionFlowControl: dynamicconfig.EnableReplicationReceiverSlowSubmissionFlowControl.Get(dc),

637 > ReplicationResendMaxBatchCount: dynamicconfig.ReplicationResendMaxBatchCount.Get(dc),

638 > ReplicationProgressCacheMaxSize: dynamicconfig.ReplicationProgressCacheMaxSize.Get(dc),

639 > ReplicationProgressCacheTTL: dynamicconfig.ReplicationProgressCacheTTL.Get(dc),

640 > ReplicationEnableRateLimit: dynamicconfig.ReplicationEnableRateLimit.Get(dc),

641 > ReplicationEnableRateLimitShadowMode: dynamicconfig.ReplicationEnableRateLimitShadowMode.Get(dc),

642 > ReplicationStreamSendEmptyTaskDuration: dynamicconfig.ReplicationStreamSendEmptyTaskDuration.Get(dc),

643 > ReplicationStreamReceiverLivenessMultiplier: dynamicconfig.ReplicationStreamReceiverLivenessMultiplier.Get(dc),

644 > ReplicationStreamSenderLivenessMultiplier: dynamicconfig.ReplicationStreamSenderLivenessMultiplier.Get(dc),

645 > EnableHistoryReplicationRateLimiter: dynamicconfig.EnableHistoryReplicationRateLimiter.Get(dc),

646 >

647 > MaximumBufferedEventsBatch: dynamicconfig.MaximumBufferedEventsBatch.Get(dc),

648 > MaximumBufferedEventsSizeInBytes: dynamicconfig.MaximumBufferedEventsSizeInBytes.Get(dc),

649 > MaximumSignalsPerExecution: dynamicconfig.MaximumSignalsPerExecution.Get(dc),

650 > MaximumEventBatchSizeInBytes: dynamicconfig.MaximumEventBatchSizeInBytes.Get(dc),

651 > ShardUpdateMinInterval: dynamicconfig.ShardUpdateMinInterval.Get(dc),

652 > ShardFirstUpdateInterval: dynamicconfig.ShardFirstUpdateInterval.Get(dc),

653 > ShardUpdateMinTasksCompleted: dynamicconfig.ShardUpdateMinTasksCompleted.Get(dc),

654 > ShardSyncMinInterval: dynamicconfig.ShardSyncMinInterval.Get(dc),

655 > ShardSyncTimerJitterCoefficient: dynamicconfig.TransferProcessorMaxPollIntervalJitterCoefficient.Get(dc),

656 >

657 > // history client: client/history/client.go set the client timeout 30s

658 > // TODO: Return this value to the client: go.temporal.io/server/issues/294

659 > LongPollExpirationInterval: dynamicconfig.HistoryLongPollExpirationInterval.Get(dc),

660 > EnableParentClosePolicy: dynamicconfig.EnableParentClosePolicy.Get(dc),

661 > NumParentClosePolicySystemWorkflows: dynamicconfig.NumParentClosePolicySystemWorkflows.Get(dc),

662 > EnableParentClosePolicyWorker: dynamicconfig.EnableParentClosePolicyWorker.Get(dc),

663 > ParentClosePolicyThreshold: dynamicconfig.ParentClosePolicyThreshold.Get(dc),

664 >

665 > BlobSizeLimitError: dynamicconfig.BlobSizeLimitError.Get(dc),

666 > BlobSizeLimitWarn: dynamicconfig.BlobSizeLimitWarn.Get(dc),

667 > MemoSizeLimitError: dynamicconfig.MemoSizeLimitError.Get(dc),

668 > MemoSizeLimitWarn: dynamicconfig.MemoSizeLimitWarn.Get(dc),

669 > NumPendingChildExecutionsLimit: dynamicconfig.NumPendingChildExecutionsLimitError.Get(dc),

670 > NumPendingActivitiesLimit: dynamicconfig.NumPendingActivitiesLimitError.Get(dc),

671 > NumPendingSignalsLimit: dynamicconfig.NumPendingSignalsLimitError.Get(dc),

672 > NumPendingCancelsRequestLimit: dynamicconfig.NumPendingCancelRequestsLimitError.Get(dc),

673 > HistorySizeLimitError: dynamicconfig.HistorySizeLimitError.Get(dc),

674 > HistorySizeLimitWarn: dynamicconfig.HistorySizeLimitWarn.Get(dc),

675 > HistorySizeSuggestContinueAsNew: dynamicconfig.HistorySizeSuggestContinueAsNew.Get(dc),

676 > HistoryCountLimitError: dynamicconfig.HistoryCountLimitError.Get(dc),

677 > HistoryCountLimitWarn: dynamicconfig.HistoryCountLimitWarn.Get(dc),

678 > HistoryCountSuggestContinueAsNew: dynamicconfig.HistoryCountSuggestContinueAsNew.Get(dc),

679 > HistoryMaxPageSize: dynamicconfig.HistoryMaxPageSize.Get(dc),

680 > MutableStateActivityFailureSizeLimitError: dynamicconfig.MutableStateActivityFailureSizeLimitError.Get(dc),

681 > MutableStateActivityFailureSizeLimitWarn: dynamicconfig.MutableStateActivityFailureSizeLimitWarn.Get(dc),

682 > MutableStateSizeLimitError: dynamicconfig.MutableStateSizeLimitError.Get(dc),

683 > MutableStateSizeLimitWarn: dynamicconfig.MutableStateSizeLimitWarn.Get(dc),

684 > MutableStateTombstoneCountLimit: dynamicconfig.MutableStateTombstoneCountLimit.Get(dc),

685 >

686 > ThrottledLogRPS: dynamicconfig.HistoryThrottledLogRPS.Get(dc),

687 > EnableStickyQuery: dynamicconfig.EnableStickyQuery.Get(dc),

688 >

689 > DefaultActivityRetryPolicy: dynamicconfig.DefaultActivityRetryPolicy.Get(dc),

690 > DefaultWorkflowRetryPolicy: dynamicconfig.DefaultWorkflowRetryPolicy.Get(dc),

691 > WorkflowTaskHeartbeatTimeout: dynamicconfig.WorkflowTaskHeartbeatTimeout.Get(dc),

692 > WorkflowTaskCriticalAttempts: dynamicconfig.WorkflowTaskCriticalAttempts.Get(dc),

693 > WorkflowTaskRetryMaxInterval: dynamicconfig.WorkflowTaskRetryMaxInterval.Get(dc),

694 > EnableWorkflowTaskStampIncrementOnFailure: dynamicconfig.EnableWorkflowTaskStampIncrementOnFailure.Get(dc),

695 > DiscardSpeculativeWorkflowTaskMaximumEventsCount: dynamicconfig.DiscardSpeculativeWorkflowTaskMaximumEventsCount.Get(dc),

696 > EnableDropRepeatedWorkflowTaskFailures: dynamicconfig.EnableDropRepeatedWorkflowTaskFailures.Get(dc),

697 > SendTransientOrSpeculativeWorkflowTaskEvents: dynamicconfig.SendTransientOrSpeculativeWorkflowTaskEvents.Get(dc),

698 >

699 > ReplicationTaskApplyTimeout: dynamicconfig.ReplicationTaskApplyTimeout.Get(dc),

700 > ReplicationTaskFetcherParallelism: dynamicconfig.ReplicationTaskFetcherParallelism.Get(dc),

701 > ReplicationTaskFetcherAggregationInterval: dynamicconfig.ReplicationTaskFetcherAggregationInterval.Get(dc),

702 > ReplicationTaskFetcherTimerJitterCoefficient: dynamicconfig.ReplicationTaskFetcherTimerJitterCoefficient.Get(dc),

703 > ReplicationTaskFetcherErrorRetryWait: dynamicconfig.ReplicationTaskFetcherErrorRetryWait.Get(dc),

704 >

705 > ReplicationTaskProcessorErrorRetryWait: dynamicconfig.ReplicationTaskProcessorErrorRetryWait.Get(dc),

706 > ReplicationTaskProcessorErrorRetryBackoffCoefficient: dynamicconfig.ReplicationTaskProcessorErrorRetryBackoffCoefficient.Get(dc),

707 > ReplicationTaskProcessorErrorRetryMaxInterval: dynamicconfig.ReplicationTaskProcessorErrorRetryMaxInterval.Get(dc),

708 > ReplicationTaskProcessorErrorRetryMaxAttempts: dynamicconfig.ReplicationTaskProcessorErrorRetryMaxAttempts.Get(dc),

709 > ReplicationTaskProcessorErrorRetryExpiration: dynamicconfig.ReplicationTaskProcessorErrorRetryExpiration.Get(dc),

710 > ReplicationTaskProcessorNoTaskRetryWait: dynamicconfig.ReplicationTaskProcessorNoTaskInitialWait.Get(dc),

711 > ReplicationTaskProcessorCleanupInterval: dynamicconfig.ReplicationTaskProcessorCleanupInterval.Get(dc),

712 > ReplicationTaskProcessorCleanupJitterCoefficient: dynamicconfig.ReplicationTaskProcessorCleanupJitterCoefficient.Get(dc),

713 > ReplicationMultipleBatches: dynamicconfig.ReplicationMultipleBatches.Get(dc),

714 >

715 > ReplicationStreamSenderErrorRetryWait: dynamicconfig.ReplicationStreamSenderErrorRetryWait.Get(dc),

716 > ReplicationStreamSenderErrorRetryBackoffCoefficient: dynamicconfig.ReplicationStreamSenderErrorRetryBackoffCoefficient.Get(dc),

717 > ReplicationStreamSenderErrorRetryMaxInterval: dynamicconfig.ReplicationStreamSenderErrorRetryMaxInterval.Get(dc),

718 > ReplicationStreamSenderErrorRetryMaxAttempts: dynamicconfig.ReplicationStreamSenderErrorRetryMaxAttempts.Get(dc),

719 > ReplicationStreamSenderErrorRetryExpiration: dynamicconfig.ReplicationStreamSenderErrorRetryExpiration.Get(dc),

720 >

721 > ReplicationExecutableTaskErrorRetryWait: dynamicconfig.ReplicationExecutableTaskErrorRetryWait.Get(dc),

722 > ReplicationExecutableTaskErrorRetryBackoffCoefficient: dynamicconfig.ReplicationExecutableTaskErrorRetryBackoffCoefficient.Get(dc),

723 > ReplicationExecutableTaskErrorRetryMaxInterval: dynamicconfig.ReplicationExecutableTaskErrorRetryMaxInterval.Get(dc),

724 > ReplicationExecutableTaskErrorRetryMaxAttempts: dynamicconfig.ReplicationExecutableTaskErrorRetryMaxAttempts.Get(dc),

725 > ReplicationExecutableTaskErrorRetryExpiration: dynamicconfig.ReplicationExecutableTaskErrorRetryExpiration.Get(dc),

726 >

727 > MaxBufferedQueryCount: dynamicconfig.MaxBufferedQueryCount.Get(dc),

728 > MutableStateChecksumGenProbability: dynamicconfig.MutableStateChecksumGenProbability.Get(dc),

729 > MutableStateChecksumVerifyProbability: dynamicconfig.MutableStateChecksumVerifyProbability.Get(dc),

730 > MutableStateChecksumInvalidateBefore: dynamicconfig.MutableStateChecksumInvalidateBefore.Get(dc),

731 >

732 > StandbyTaskReReplicationContextTimeout: dynamicconfig.StandbyTaskReReplicationContextTimeout.Get(dc),

733 >

734 > SkipReapplicationByNamespaceID: dynamicconfig.SkipReapplicationByNamespaceID.Get(dc),

735 >

736 > // ===== Visibility related =====

737 > VisibilityTaskBatchSize: dynamicconfig.VisibilityTaskBatchSize.Get(dc),

738 > VisibilityProcessorMaxPollRPS: dynamicconfig.VisibilityProcessorMaxPollRPS.Get(dc),

739 > VisibilityProcessorMaxPollHostRPS: dynamicconfig.VisibilityProcessorMaxPollHostRPS.Get(dc),

740 > VisibilityProcessorSchedulerWorkerCount: dynamicconfig.VisibilityProcessorSchedulerWorkerCount.Subscribe(dc),

741 > VisibilityProcessorSchedulerActiveRoundRobinWeights: dynamicconfig.VisibilityProcessorSchedulerActiveRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultActiveTaskPriorityWeight)).Get(dc),

742 > VisibilityProcessorSchedulerStandbyRoundRobinWeights: dynamicconfig.VisibilityProcessorSchedulerStandbyRoundRobinWeights.WithDefault(ConvertWeightsToDynamicConfigValue(DefaultStandbyTaskPriorityWeight)).Get(dc),

743 > VisibilityProcessorMaxPollInterval: dynamicconfig.VisibilityProcessorMaxPollInterval.Get(dc),

744 > VisibilityProcessorMaxPollIntervalJitterCoefficient: dynamicconfig.VisibilityProcessorMaxPollIntervalJitterCoefficient.Get(dc),

745 > VisibilityProcessorUpdateAckInterval: dynamicconfig.VisibilityProcessorUpdateAckInterval.Get(dc),

746 > VisibilityProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.VisibilityProcessorUpdateAckIntervalJitterCoefficient.Get(dc),

747 > VisibilityProcessorPollBackoffInterval: dynamicconfig.VisibilityProcessorPollBackoffInterval.Get(dc),

748 > VisibilityProcessorEnsureCloseBeforeDelete: dynamicconfig.VisibilityProcessorEnsureCloseBeforeDelete.Get(dc),

749 > VisibilityProcessorEnableCloseWorkflowCleanup: dynamicconfig.VisibilityProcessorEnableCloseWorkflowCleanup.Get(dc),

750 > VisibilityProcessorRelocateAttributesMinBlobSize: dynamicconfig.VisibilityProcessorRelocateAttributesMinBlobSize.Get(dc),

751 > VisibilityQueueMaxReaderCount: dynamicconfig.VisibilityQueueMaxReaderCount.Get(dc),

752 >

753 > DisableFetchRelocatableAttributesFromVisibility: dynamicconfig.DisableFetchRelocatableAttributesFromVisibility.Get(dc),

754 >

755 > SearchAttributesNumberOfKeysLimit: dynamicconfig.SearchAttributesNumberOfKeysLimit.Get(dc),

756 > SearchAttributesSizeOfValueLimit: dynamicconfig.SearchAttributesSizeOfValueLimit.Get(dc),

757 > SearchAttributesTotalSizeLimit: dynamicconfig.SearchAttributesTotalSizeLimit.Get(dc),

758 > IndexerConcurrency: dynamicconfig.WorkerIndexerConcurrency.Get(dc),

759 > ESProcessorNumOfWorkers: dynamicconfig.WorkerESProcessorNumOfWorkers.Get(dc),

760 > // Should not be greater than number of visibility task queue workers VisibilityProcessorSchedulerWorkerCount (default 512)

761 > // Otherwise, visibility queue processors won't be able to fill up bulk with documents (even under heavy load) and bulk will flush due to interval, not number of actions.

762 > ESProcessorBulkActions: dynamicconfig.WorkerESProcessorBulkActions.Get(dc),

763 > // 16MB - just a sanity check. With ES document size ~1Kb it should never be reached.

764 > ESProcessorBulkSize: dynamicconfig.WorkerESProcessorBulkSize.Get(dc),

765 > // Bulk processor will flush every this interval regardless of last flush due to bulk actions.

766 > ESProcessorFlushInterval: dynamicconfig.WorkerESProcessorFlushInterval.Get(dc),

767 > ESProcessorAckTimeout: dynamicconfig.WorkerESProcessorAckTimeout.Get(dc),

768 >

769 > EnableCrossNamespaceCommands: dynamicconfig.EnableCrossNamespaceCommands.Get(dc),

770 > EnableActivityEagerExecution: dynamicconfig.EnableActivityEagerExecution.Get(dc),

771 > EnableActivityRetryStampIncrement: dynamicconfig.EnableActivityRetryStampIncrement.Get(dc),

772 > EnableCancelActivityWorkerCommand: dynamicconfig.EnableCancelActivityWorkerCommand.Get(dc),

773 > EnableEagerWorkflowStart: dynamicconfig.EnableEagerWorkflowStart.Get(dc),

774 > NamespaceCacheRefreshInterval: dynamicconfig.NamespaceCacheRefreshInterval.Get(dc),

775 >

776 > // Archival related

777 > ArchivalTaskBatchSize: dynamicconfig.ArchivalTaskBatchSize.Get(dc),

778 > ArchivalProcessorMaxPollRPS: dynamicconfig.ArchivalProcessorMaxPollRPS.Get(dc),

779 > ArchivalProcessorMaxPollHostRPS: dynamicconfig.ArchivalProcessorMaxPollHostRPS.Get(dc),

780 > ArchivalProcessorSchedulerWorkerCount: dynamicconfig.ArchivalProcessorSchedulerWorkerCount.Subscribe(dc),

781 > ArchivalProcessorMaxPollInterval: dynamicconfig.ArchivalProcessorMaxPollInterval.Get(dc),

782 > ArchivalProcessorMaxPollIntervalJitterCoefficient: dynamicconfig.ArchivalProcessorMaxPollIntervalJitterCoefficient.Get(dc),

783 > ArchivalProcessorUpdateAckInterval: dynamicconfig.ArchivalProcessorUpdateAckInterval.Get(dc),

784 > ArchivalProcessorUpdateAckIntervalJitterCoefficient: dynamicconfig.ArchivalProcessorUpdateAckIntervalJitterCoefficient.Get(dc),

785 > ArchivalProcessorPollBackoffInterval: dynamicconfig.ArchivalProcessorPollBackoffInterval.Get(dc),

786 > ArchivalProcessorArchiveDelay: dynamicconfig.ArchivalProcessorArchiveDelay.Get(dc),

787 > ArchivalBackendMaxRPS: dynamicconfig.ArchivalBackendMaxRPS.Get(dc),

788 > ArchivalQueueMaxReaderCount: dynamicconfig.ArchivalQueueMaxReaderCount.Get(dc),

789 >

790 > // workflow update related

791 > WorkflowExecutionMaxInFlightUpdates: dynamicconfig.WorkflowExecutionMaxInFlightUpdates.Get(dc),

792 > WorkflowExecutionMaxInFlightUpdatePayloads: dynamicconfig.WorkflowExecutionMaxInFlightUpdatePayloads.Get(dc),

793 > WorkflowExecutionMaxTotalUpdates: dynamicconfig.WorkflowExecutionMaxTotalUpdates.Get(dc),

794 > WorkflowExecutionMaxTotalUpdatesSuggestContinueAsNewThreshold: dynamicconfig.WorkflowExecutionMaxTotalUpdatesSuggestContinueAsNewThreshold.Get(dc),

795 > EnableUpdateWithStartRetryOnClosedWorkflowAbort: dynamicconfig.EnableUpdateWithStartRetryOnClosedWorkflowAbort.Get(dc),

796 > EnableUpdateWithStartRetryableErrorOnClosedWorkflowAbort: dynamicconfig.EnableUpdateWithStartRetryableErrorOnClosedWorkflowAbort.Get(dc),

797 >

798 > SendRawHistoryBetweenInternalServices: dynamicconfig.SendRawHistoryBetweenInternalServices.Get(dc),

799 > SendRawHistoryBytesToMatchingService: dynamicconfig.SendRawHistoryBytesToMatchingService.Get(dc),

800 > SendRawWorkflowHistory: dynamicconfig.SendRawWorkflowHistory.Get(dc),

801 > WorkflowIdReuseMinimalInterval: dynamicconfig.WorkflowIdReuseMinimalInterval.Get(dc),

802 > EnableWorkflowIdReuseStartTimeValidation: dynamicconfig.EnableWorkflowIdReuseStartTimeValidation.Get(dc),

803 > BusinessIDReuseRate: dynamicconfig.BusinessIDReuseRate.Get(dc),

804 > BusinessIDReuseBurstRatio: dynamicconfig.BusinessIDReuseBurstRatio.Get(dc),

805 > BusinessIDReuseLimiterCacheSize: dynamicconfig.BusinessIDReuseLimiterCacheSize.Get(dc),

806 > BusinessIDReuseLimiterCacheTTL: dynamicconfig.BusinessIDReuseLimiterCacheTTL.Get(dc),

807 >

808 > HealthPersistenceLatencyFailure: dynamicconfig.HealthPersistenceLatencyFailure.Get(dc),

809 > HealthPersistenceLatencyPercentiles: dynamicconfig.PersistenceHealthSignalPercentileLatencySettings.Get(dc),

810 > HealthPersistenceErrorRatio: dynamicconfig.HealthPersistenceErrorRatio.Get(dc),

811 > HealthRPCLatencyFailure: dynamicconfig.HealthRPCLatencyFailure.Get(dc),

812 > HealthRPCLatencyPercentiles: dynamicconfig.HistoryHealthSignalPercentileLatencySettings.Get(dc),

813 > HealthRPCErrorRatio: dynamicconfig.HealthRPCErrorRatio.Get(dc),

814 > HealthHistoryInitializationTime: dynamicconfig.HealthHistoryInitializationTime.Get(dc),

815 >

816 > BreakdownMetricsByTaskQueue: dynamicconfig.MetricsBreakdownByTaskQueue.Get(dc),

817 >

818 > LogAllReqErrors: dynamicconfig.LogAllReqErrors.Get(dc),

819 >

820 > NumConsecutiveWorkflowTaskProblemsToTriggerSearchAttribute: dynamicconfig.NumConsecutiveWorkflowTaskProblemsToTriggerSearchAttribute.Get(dc),

821 >

822 > // Worker-Versioning related

823 > UseRevisionNumberForWorkerVersioning: dynamicconfig.UseRevisionNumberForWorkerVersioning.Get(dc),

824 > EnableSuggestCaNOnNewTargetVersion: dynamicconfig.EnableSuggestCaNOnNewTargetVersion.Get(dc),

825 > EnableSendTargetVersionChanged: dynamicconfig.EnableSendTargetVersionChanged.Get(dc),

826 > VersionMembershipCacheTTL: dynamicconfig.VersionMembershipCacheTTL.Get(dc),

827 > VersionMembershipCacheMaxSize: dynamicconfig.VersionMembershipCacheMaxSize.Get(dc),

828 > EnableVersionReactivationSignals: dynamicconfig.EnableVersionReactivationSignals.Get(dc),

829 > RoutingInfoCacheTTL: dynamicconfig.RoutingInfoCacheTTL.Get(dc),

830 > RoutingInfoCacheMaxSize: dynamicconfig.RoutingInfoCacheMaxSize.Get(dc),

831 >

832 > // Workflow task completion pagination

833 > EnableWorkflowTaskCompletionPagination: dynamicconfig.EnableWorkflowTaskCompletionPagination.Get(dc),

834 > WorkflowTaskCompletionBufferSizeLimit: dynamicconfig.WorkflowTaskCompletionBufferSizeLimit.Get(dc),

835 > }

836 >

837 > return cfg

838 > }

839

840 // GetShardID return the corresponding shard ID for a given namespaceID and workflowID pair

go.temporal.io/server/common/dynamicconfig/setting_gen.go 301 covered LOC · 69 ranges

Open complete file

26 type GlobalBoolConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[bool]

27

28 > func NewGlobalBoolSetting(key string, def bool, description string) GlobalBoolSetting { setting_gen.go

29 > return NewGlobalTypedSettingWithConverter[bool](key, convertBool, def, description)

30 > }

31

32 func NewGlobalBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) GlobalBoolConstrainedDefaultSetting {

36 type BoolPropertyFn = TypedPropertyFn[bool]

37

38 > func GetBoolPropertyFn(value bool) BoolPropertyFn { setting_gen.go

39 > return GetTypedPropertyFn(value)

40 > }

41

42 type NamespaceBoolSetting = NamespaceTypedSetting[bool]

43 type NamespaceBoolConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[bool]

44

45 > func NewNamespaceBoolSetting(key string, def bool, description string) NamespaceBoolSetting { setting_gen.go

46 > return NewNamespaceTypedSettingWithConverter[bool](key, convertBool, def, description)

47 > }

48

49 func NewNamespaceBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) NamespaceBoolConstrainedDefaultSetting {

53 type BoolPropertyFnWithNamespaceFilter = TypedPropertyFnWithNamespaceFilter[bool]

54

55 > func GetBoolPropertyFnFilteredByNamespace(value bool) BoolPropertyFnWithNamespaceFilter { setting_gen.go

56 > return GetTypedPropertyFnFilteredByNamespace(value)

57 > }

58

59 type NamespaceIDBoolSetting = NamespaceIDTypedSetting[bool]

60 type NamespaceIDBoolConstrainedDefaultSetting = NamespaceIDTypedConstrainedDefaultSetting[bool]

61

62 > func NewNamespaceIDBoolSetting(key string, def bool, description string) NamespaceIDBoolSetting { setting_gen.go

63 > return NewNamespaceIDTypedSettingWithConverter[bool](key, convertBool, def, description)

64 > }

65

66 func NewNamespaceIDBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) NamespaceIDBoolConstrainedDefaultSetting {

77 type TaskQueueBoolConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[bool]

78

79 > func NewTaskQueueBoolSetting(key string, def bool, description string) TaskQueueBoolSetting { setting_gen.go

80 > return NewTaskQueueTypedSettingWithConverter[bool](key, convertBool, def, description)

81 > }

82

83 func NewTaskQueueBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) TaskQueueBoolConstrainedDefaultSetting {

128 type DestinationBoolConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[bool]

129

130 > func NewDestinationBoolSetting(key string, def bool, description string) DestinationBoolSetting { setting_gen.go

131 > return NewDestinationTypedSettingWithConverter[bool](key, convertBool, def, description)

132 > }

133

134 func NewDestinationBoolSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[bool], description string) DestinationBoolConstrainedDefaultSetting {

162 type GlobalIntConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[int]

163

164 > func NewGlobalIntSetting(key string, def int, description string) GlobalIntSetting { setting_gen.go

165 > return NewGlobalTypedSettingWithConverter[int](key, convertInt, def, description)

166 > }

167

168 func NewGlobalIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) GlobalIntConstrainedDefaultSetting {

179 type NamespaceIntConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[int]

180

181 > func NewNamespaceIntSetting(key string, def int, description string) NamespaceIntSetting { setting_gen.go

182 > return NewNamespaceTypedSettingWithConverter[int](key, convertInt, def, description)

183 > }

184

185 func NewNamespaceIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) NamespaceIntConstrainedDefaultSetting {

189 type IntPropertyFnWithNamespaceFilter = TypedPropertyFnWithNamespaceFilter[int]

190

191 > func GetIntPropertyFnFilteredByNamespace(value int) IntPropertyFnWithNamespaceFilter { setting_gen.go

192 > return GetTypedPropertyFnFilteredByNamespace(value)

193 > }

194

195 type NamespaceIDIntSetting = NamespaceIDTypedSetting[int]

213 type TaskQueueIntConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[int]

214

215 > func NewTaskQueueIntSetting(key string, def int, description string) TaskQueueIntSetting { setting_gen.go

216 > return NewTaskQueueTypedSettingWithConverter[int](key, convertInt, def, description)

217 > }

218

219 > func NewTaskQueueIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) TaskQueueIntConstrainedDefaultSetting { setting_gen.go

220 > return NewTaskQueueTypedSettingWithConstrainedDefault[int](key, convertInt, cdef, description)

221 > }

222

223 type IntPropertyFnWithTaskQueueFilter = TypedPropertyFnWithTaskQueueFilter[int]

230 type ShardIDIntConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[int]

231

232 > func NewShardIDIntSetting(key string, def int, description string) ShardIDIntSetting { setting_gen.go

233 > return NewShardIDTypedSettingWithConverter[int](key, convertInt, def, description)

234 > }

235

236 func NewShardIDIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) ShardIDIntConstrainedDefaultSetting {

264 type DestinationIntConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[int]

265

266 > func NewDestinationIntSetting(key string, def int, description string) DestinationIntSetting { setting_gen.go

267 > return NewDestinationTypedSettingWithConverter[int](key, convertInt, def, description)

268 > }

269

270 func NewDestinationIntSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[int], description string) DestinationIntConstrainedDefaultSetting {

298 type GlobalFloatConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[float64]

299

300 > func NewGlobalFloatSetting(key string, def float64, description string) GlobalFloatSetting { setting_gen.go

301 > return NewGlobalTypedSettingWithConverter[float64](key, convertFloat, def, description)

302 > }

303

304 func NewGlobalFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) GlobalFloatConstrainedDefaultSetting {

315 type NamespaceFloatConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[float64]

316

317 > func NewNamespaceFloatSetting(key string, def float64, description string) NamespaceFloatSetting { setting_gen.go

318 > return NewNamespaceTypedSettingWithConverter[float64](key, convertFloat, def, description)

319 > }

320

321 func NewNamespaceFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) NamespaceFloatConstrainedDefaultSetting {

349 type TaskQueueFloatConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[float64]

350

351 > func NewTaskQueueFloatSetting(key string, def float64, description string) TaskQueueFloatSetting { setting_gen.go

352 > return NewTaskQueueTypedSettingWithConverter[float64](key, convertFloat, def, description)

353 > }

354

355 func NewTaskQueueFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) TaskQueueFloatConstrainedDefaultSetting {

366 type ShardIDFloatConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[float64]

367

368 > func NewShardIDFloatSetting(key string, def float64, description string) ShardIDFloatSetting { setting_gen.go

369 > return NewShardIDTypedSettingWithConverter[float64](key, convertFloat, def, description)

370 > }

371

372 func NewShardIDFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) ShardIDFloatConstrainedDefaultSetting {

400 type DestinationFloatConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[float64]

401

402 > func NewDestinationFloatSetting(key string, def float64, description string) DestinationFloatSetting { setting_gen.go

403 > return NewDestinationTypedSettingWithConverter[float64](key, convertFloat, def, description)

404 > }

405

406 func NewDestinationFloatSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[float64], description string) DestinationFloatConstrainedDefaultSetting {

434 type GlobalStringConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[string]

435

436 > func NewGlobalStringSetting(key string, def string, description string) GlobalStringSetting { setting_gen.go

437 > return NewGlobalTypedSettingWithConverter[string](key, convertString, def, description)

438 > }

439

440 func NewGlobalStringSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[string], description string) GlobalStringConstrainedDefaultSetting {

570 type GlobalDurationConstrainedDefaultSetting = GlobalTypedConstrainedDefaultSetting[time.Duration]

571

572 > func NewGlobalDurationSetting(key string, def time.Duration, description string) GlobalDurationSetting { setting_gen.go

573 > return NewGlobalTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

574 > }

575

576 func NewGlobalDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) GlobalDurationConstrainedDefaultSetting {

580 type DurationPropertyFn = TypedPropertyFn[time.Duration]

581

582 > func GetDurationPropertyFn(value time.Duration) DurationPropertyFn { setting_gen.go

583 > return GetTypedPropertyFn(value)

584 > }

585

586 type NamespaceDurationSetting = NamespaceTypedSetting[time.Duration]

587 type NamespaceDurationConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[time.Duration]

588

589 > func NewNamespaceDurationSetting(key string, def time.Duration, description string) NamespaceDurationSetting { setting_gen.go

590 > return NewNamespaceTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

591 > }

592

593 func NewNamespaceDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) NamespaceDurationConstrainedDefaultSetting {

604 type NamespaceIDDurationConstrainedDefaultSetting = NamespaceIDTypedConstrainedDefaultSetting[time.Duration]

605

606 > func NewNamespaceIDDurationSetting(key string, def time.Duration, description string) NamespaceIDDurationSetting { setting_gen.go

607 > return NewNamespaceIDTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

608 > }

609

610 func NewNamespaceIDDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) NamespaceIDDurationConstrainedDefaultSetting {

621 type TaskQueueDurationConstrainedDefaultSetting = TaskQueueTypedConstrainedDefaultSetting[time.Duration]

622

623 > func NewTaskQueueDurationSetting(key string, def time.Duration, description string) TaskQueueDurationSetting { setting_gen.go

624 > return NewTaskQueueTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

625 > }

626

627 > func NewTaskQueueDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) TaskQueueDurationConstrainedDefaultSetting { setting_gen.go

628 > return NewTaskQueueTypedSettingWithConstrainedDefault[time.Duration](key, convertDuration, cdef, description)

629 > }

630

631 type DurationPropertyFnWithTaskQueueFilter = TypedPropertyFnWithTaskQueueFilter[time.Duration]

638 type ShardIDDurationConstrainedDefaultSetting = ShardIDTypedConstrainedDefaultSetting[time.Duration]

639

640 > func NewShardIDDurationSetting(key string, def time.Duration, description string) ShardIDDurationSetting { setting_gen.go

641 > return NewShardIDTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

642 > }

643

644 func NewShardIDDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) ShardIDDurationConstrainedDefaultSetting {

655 type TaskTypeDurationConstrainedDefaultSetting = TaskTypeTypedConstrainedDefaultSetting[time.Duration]

656

657 > func NewTaskTypeDurationSetting(key string, def time.Duration, description string) TaskTypeDurationSetting { setting_gen.go

658 > return NewTaskTypeTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

659 > }

660

661 func NewTaskTypeDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) TaskTypeDurationConstrainedDefaultSetting {

672 type DestinationDurationConstrainedDefaultSetting = DestinationTypedConstrainedDefaultSetting[time.Duration]

673

674 > func NewDestinationDurationSetting(key string, def time.Duration, description string) DestinationDurationSetting { setting_gen.go

675 > return NewDestinationTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

676 > }

677

678 func NewDestinationDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) DestinationDurationConstrainedDefaultSetting {

689 type ChasmTaskTypeDurationConstrainedDefaultSetting = ChasmTaskTypeTypedConstrainedDefaultSetting[time.Duration]

690

691 > func NewChasmTaskTypeDurationSetting(key string, def time.Duration, description string) ChasmTaskTypeDurationSetting { setting_gen.go

692 > return NewChasmTaskTypeTypedSettingWithConverter[time.Duration](key, convertDuration, def, description)

693 > }

694

695 func NewChasmTaskTypeDurationSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[time.Duration], description string) ChasmTaskTypeDurationConstrainedDefaultSetting {

723 type NamespaceMapConstrainedDefaultSetting = NamespaceTypedConstrainedDefaultSetting[map[string]any]

724

725 > func NewNamespaceMapSetting(key string, def map[string]any, description string) NamespaceMapSetting { setting_gen.go

726 > return NewNamespaceTypedSettingWithConverter[map[string]any](key, convertMap, def, description)

727 > }

728

729 func NewNamespaceMapSettingWithConstrainedDefault(key string, cdef []TypedConstrainedValue[map[string]any], description string) NamespaceMapConstrainedDefaultSetting {

845 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

846 // when using non-empty maps or slices as defaults, the result may not be what you want.

847 > func NewGlobalTypedSetting[T any](key string, def T, description string) GlobalTypedSetting[T] { setting_gen.go

848 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

849 > warnDefaultSharedStructure(key, def)

850 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

851 > _ = deepCopyForMapstructure(def)

852 >

853 > s := GlobalTypedSetting[T]{

854 > key: MakeKey(key),

855 > def: def,

856 > convert: ConvertStructure[T](def),

857 > description: description,

858 > }

859 > register(s)

860 > return s

861 > }

862

863 // NewGlobalTypedSettingWithConverter creates a setting with a custom converter function.

864 > func NewGlobalTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) GlobalTypedSetting[T] { setting_gen.go

865 > s := GlobalTypedSetting[T]{

866 > key: MakeKey(key),

867 > def: def,

868 > convert: convert,

869 > description: description,

870 > }

871 > register(s)

872 > return s

873 > }

874

875 // NewGlobalTypedSettingWithConstrainedDefault creates a setting with a compound default value.

885 }

886

887 > func (s GlobalTypedSetting[T]) Key() Key { return s.key } setting_gen.go

888 func (s GlobalTypedSetting[T]) Precedence() Precedence { return PrecedenceGlobal }

889 func (s GlobalTypedSetting[T]) Validate(v any) error {

907 type TypedPropertyFn[T any] func() T

908

909 > func (s GlobalTypedSetting[T]) Get(c *Collection) TypedPropertyFn[T] { setting_gen.go

910 > return func() T {

911 > prec := []Constraints{{}} setting_gen.go

912 > return matchAndConvert(

913 > c,

914 > s.key,

915 > s.def,

916 > s.convert,

917 > prec,

918 > )

919 > }

920 }

921

935 type TypedSubscribable[T any] func(callback func(T)) (v T, cancel func())

936

937 > func (s GlobalTypedSetting[T]) Subscribe(c *Collection) TypedSubscribable[T] { setting_gen.go

938 > return func(callback func(T)) (T, func()) {

939 prec := []Constraints{{}}

940 return subscribe(c, s.key, s.def, s.convert, prec, callback)

969 }

970

971 > func GetTypedPropertyFn[T any](value T) TypedPropertyFn[T] { setting_gen.go

972 > return func() T {

973 return value

974 }

981 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

982 // when using non-empty maps or slices as defaults, the result may not be what you want.

983 > func NewNamespaceTypedSetting[T any](key string, def T, description string) NamespaceTypedSetting[T] { setting_gen.go

984 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

985 > warnDefaultSharedStructure(key, def)

986 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

987 > _ = deepCopyForMapstructure(def)

988 >

989 > s := NamespaceTypedSetting[T]{

990 > key: MakeKey(key),

991 > def: def,

992 > convert: ConvertStructure[T](def),

993 > description: description,

994 > }

995 > register(s)

996 > return s

997 > }

998

999 // NewNamespaceTypedSettingWithConverter creates a setting with a custom converter function.

1000 > func NewNamespaceTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceTypedSetting[T] { setting_gen.go

1001 > s := NamespaceTypedSetting[T]{

1002 > key: MakeKey(key),

1003 > def: def,

1004 > convert: convert,

1005 > description: description,

1006 > }

1007 > register(s)

1008 > return s

1009 > }

1010

1011 // NewNamespaceTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1021 }

1022

1023 > func (s NamespaceTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1024 func (s NamespaceTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespace }

1025 func (s NamespaceTypedSetting[T]) Validate(v any) error {

1035 }

1036

1037 > func (s NamespaceTypedSetting[T]) WithDefault(v T) NamespaceTypedSetting[T] { setting_gen.go

1038 > newS := s

1039 > newS.def = v

1040 > return newS

1041 > }

1042

1043 type TypedPropertyFnWithNamespaceFilter[T any] func(namespace string) T

1044

1045 > func (s NamespaceTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithNamespaceFilter[T] { setting_gen.go

1046 > return func(namespace string) T {

1047 > prec := []Constraints{{Namespace: namespace}, {}} setting_gen.go

1048 > return matchAndConvert(

1049 > c,

1050 > s.key,

1051 > s.def,

1052 > s.convert,

1053 > prec,

1054 > )

1055 > }

1056 }

1057

1105 }

1106

1107 > func GetTypedPropertyFnFilteredByNamespace[T any](value T) TypedPropertyFnWithNamespaceFilter[T] { setting_gen.go

1108 > return func(namespace string) T {

1109 > return value setting_gen.go

1110 > }

1111 }

1112

1134

1135 // NewNamespaceIDTypedSettingWithConverter creates a setting with a custom converter function.

1136 > func NewNamespaceIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceIDTypedSetting[T] { setting_gen.go

1137 > s := NamespaceIDTypedSetting[T]{

1138 > key: MakeKey(key),

1139 > def: def,

1140 > convert: convert,

1141 > description: description,

1142 > }

1143 > register(s)

1144 > return s

1145 > }

1146

1147 // NewNamespaceIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1157 }

1158

1159 > func (s NamespaceIDTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1160 func (s NamespaceIDTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespaceID }

1161 func (s NamespaceIDTypedSetting[T]) Validate(v any) error {

1179 type TypedPropertyFnWithNamespaceIDFilter[T any] func(namespaceID namespace.ID) T

1180

1181 > func (s NamespaceIDTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithNamespaceIDFilter[T] { setting_gen.go

1182 > return func(namespaceID namespace.ID) T {

1183 prec := []Constraints{{NamespaceID: namespaceID.String()}, {}}

1184 return matchAndConvert(

1253 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

1254 // when using non-empty maps or slices as defaults, the result may not be what you want.

1255 > func NewTaskQueueTypedSetting[T any](key string, def T, description string) TaskQueueTypedSetting[T] { setting_gen.go

1256 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

1257 > warnDefaultSharedStructure(key, def)

1258 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

1259 > _ = deepCopyForMapstructure(def)

1260 >

1261 > s := TaskQueueTypedSetting[T]{

1262 > key: MakeKey(key),

1263 > def: def,

1264 > convert: ConvertStructure[T](def),

1265 > description: description,

1266 > }

1267 > register(s)

1268 > return s

1269 > }

1270

1271 // NewTaskQueueTypedSettingWithConverter creates a setting with a custom converter function.

1272 > func NewTaskQueueTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskQueueTypedSetting[T] { setting_gen.go

1273 > s := TaskQueueTypedSetting[T]{

1274 > key: MakeKey(key),

1275 > def: def,

1276 > convert: convert,

1277 > description: description,

1278 > }

1279 > register(s)

1280 > return s

1281 > }

1282

1283 // NewTaskQueueTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1284 > func NewTaskQueueTypedSettingWithConstrainedDefault[T any](key string, convert func(any) (T, error), cdef []TypedConstrainedValue[T], description string) TaskQueueTypedConstrainedDefaultSetting[T] { setting_gen.go

1285 > s := TaskQueueTypedConstrainedDefaultSetting[T]{

1286 > key: MakeKey(key),

1287 > cdef: cdef,

1288 > convert: convert,

1289 > description: description,

1290 > }

1291 > register(s)

1292 > return s

1293 > }

1294

1295 > func (s TaskQueueTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1296 func (s TaskQueueTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }

1297 func (s TaskQueueTypedSetting[T]) Validate(v any) error {

1300 }

1301

1302 > func (s TaskQueueTypedConstrainedDefaultSetting[T]) Key() Key { return s.key } setting_gen.go

1303 func (s TaskQueueTypedConstrainedDefaultSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }

1304 func (s TaskQueueTypedConstrainedDefaultSetting[T]) Validate(v any) error {

1315 type TypedPropertyFnWithTaskQueueFilter[T any] func(namespace string, taskQueue string, taskQueueType enumspb.TaskQueueType) T

1316

1317 > func (s TaskQueueTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithTaskQueueFilter[T] { setting_gen.go

1318 > return func(namespace string, taskQueue string, taskQueueType enumspb.TaskQueueType) T {

1319 prec := []Constraints{

1320 {Namespace: namespace, TaskQueueName: taskQueue, TaskQueueType: taskQueueType},

1430

1431 // NewShardIDTypedSettingWithConverter creates a setting with a custom converter function.

1432 > func NewShardIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ShardIDTypedSetting[T] { setting_gen.go

1433 > s := ShardIDTypedSetting[T]{

1434 > key: MakeKey(key),

1435 > def: def,

1436 > convert: convert,

1437 > description: description,

1438 > }

1439 > register(s)

1440 > return s

1441 > }

1442

1443 // NewShardIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1453 }

1454

1455 > func (s ShardIDTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1456 func (s ShardIDTypedSetting[T]) Precedence() Precedence { return PrecedenceShardID }

1457 func (s ShardIDTypedSetting[T]) Validate(v any) error {

1475 type TypedPropertyFnWithShardIDFilter[T any] func(shardID int32) T

1476

1477 > func (s ShardIDTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithShardIDFilter[T] { setting_gen.go

1478 > return func(shardID int32) T {

1479 prec := []Constraints{{ShardID: shardID}, {}}

1480 return matchAndConvert(

1566

1567 // NewTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.

1568 > func NewTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskTypeTypedSetting[T] { setting_gen.go

1569 > s := TaskTypeTypedSetting[T]{

1570 > key: MakeKey(key),

1571 > def: def,

1572 > convert: convert,

1573 > description: description,

1574 > }

1575 > register(s)

1576 > return s

1577 > }

1578

1579 // NewTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1589 }

1590

1591 > func (s TaskTypeTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1592 func (s TaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskType }

1593 func (s TaskTypeTypedSetting[T]) Validate(v any) error {

1611 type TypedPropertyFnWithTaskTypeFilter[T any] func(taskType enumsspb.TaskType) T

1612

1613 > func (s TaskTypeTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithTaskTypeFilter[T] { setting_gen.go

1614 > return func(taskType enumsspb.TaskType) T {

1615 prec := []Constraints{{TaskType: taskType}, {}}

1616 return matchAndConvert(

1685 // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful

1686 // when using non-empty maps or slices as defaults, the result may not be what you want.

1687 > func NewDestinationTypedSetting[T any](key string, def T, description string) DestinationTypedSetting[T] { setting_gen.go

1688 > // Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.

1689 > warnDefaultSharedStructure(key, def)

1690 > // If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.

1691 > _ = deepCopyForMapstructure(def)

1692 >

1693 > s := DestinationTypedSetting[T]{

1694 > key: MakeKey(key),

1695 > def: def,

1696 > convert: ConvertStructure[T](def),

1697 > description: description,

1698 > }

1699 > register(s)

1700 > return s

1701 > }

1702

1703 // NewDestinationTypedSettingWithConverter creates a setting with a custom converter function.

1704 > func NewDestinationTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) DestinationTypedSetting[T] { setting_gen.go

1705 > s := DestinationTypedSetting[T]{

1706 > key: MakeKey(key),

1707 > def: def,

1708 > convert: convert,

1709 > description: description,

1710 > }

1711 > register(s)

1712 > return s

1713 > }

1714

1715 // NewDestinationTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1725 }

1726

1727 > func (s DestinationTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1728 func (s DestinationTypedSetting[T]) Precedence() Precedence { return PrecedenceDestination }

1729 func (s DestinationTypedSetting[T]) Validate(v any) error {

1747 type TypedPropertyFnWithDestinationFilter[T any] func(namespace string, destination string) T

1748

1749 > func (s DestinationTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithDestinationFilter[T] { setting_gen.go

1750 > return func(namespace string, destination string) T {

1751 prec := []Constraints{

1752 {Namespace: namespace, Destination: destination},

1785 type TypedSubscribableWithDestinationFilter[T any] func(namespace string, destination string, callback func(T)) (v T, cancel func())

1786

1787 > func (s DestinationTypedSetting[T]) Subscribe(c *Collection) TypedSubscribableWithDestinationFilter[T] { setting_gen.go

1788 > return func(namespace string, destination string, callback func(T)) (T, func()) {

1789 prec := []Constraints{

1790 {Namespace: namespace, Destination: destination},

1858

1859 // NewChasmTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.

1860 > func NewChasmTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ChasmTaskTypeTypedSetting[T] { setting_gen.go

1861 > s := ChasmTaskTypeTypedSetting[T]{

1862 > key: MakeKey(key),

1863 > def: def,

1864 > convert: convert,

1865 > description: description,

1866 > }

1867 > register(s)

1868 > return s

1869 > }

1870

1871 // NewChasmTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

1881 }

1882

1883 > func (s ChasmTaskTypeTypedSetting[T]) Key() Key { return s.key } setting_gen.go

1884 func (s ChasmTaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceChasmTaskType }

1885 func (s ChasmTaskTypeTypedSetting[T]) Validate(v any) error {

1903 type TypedPropertyFnWithChasmTaskTypeFilter[T any] func(chasmTaskType string) T

1904

1905 > func (s ChasmTaskTypeTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithChasmTaskTypeFilter[T] { setting_gen.go

1906 > return func(chasmTaskType string) T {

1907 prec := []Constraints{{ChasmTaskType: chasmTaskType}, {}}

1908 return matchAndConvert(

go.temporal.io/server/service/history/chasm_engine.go 205 covered LOC · 49 ranges

Open complete file

86 historyServiceResolver membership.ServiceResolver,

87 hostInfoProvider membership.HostInfoProvider,

88 > ) *ChasmEngine { chasm_engine.go

89 > return &ChasmEngine{

90 > executionCache: executionCache,

91 > registry: registry,

92 > config: config,

93 > notifier: notifier,

94 > logger: logger,

95 > historyServiceResolver: historyServiceResolver,

96 > hostInfoProvider: hostInfoProvider,

97 > }

98 > }

99

100 // This is for breaking fx cycle dependency.

102 func (e *ChasmEngine) SetShardController(

103 shardController shard.Controller,

104 > ) { chasm_engine.go

105 > e.shardController = shardController

106 > }

107

108 func (e *ChasmEngine) NotifyExecution(key chasm.ExecutionKey) {

178 startFn func(chasm.MutableContext) (chasm.RootComponent, error),

179 opts ...chasm.TransitionOption,

180 > ) (chasm.StartExecutionResult, error) { chasm_engine.go

181 > options := e.constructTransitionOptions(opts...)

182 > result, err := e.startExecution(ctx, executionRef, startFn, options)

183 > return result, e.convertError(err, executionRef, options.RequestID)

184 > }

185

186 func (e *ChasmEngine) startExecution(

189 startFn func(chasm.MutableContext) (chasm.RootComponent, error),

190 options chasm.TransitionOptions,

191 > ) (result chasm.StartExecutionResult, retErr error) { chasm_engine.go

192 > shardContext, err := e.getShardContext(executionRef)

193 > if err != nil {

194 return chasm.StartExecutionResult{}, err

195 }

196

197 > archetypeID, err := executionRef.ArchetypeID(e.registry) chasm_engine.go

198 > if err != nil {

199 return chasm.StartExecutionResult{}, err

200 }

201

202 > if executionRef.RunID != "" { chasm_engine.go

203 return chasm.StartExecutionResult{}, serviceerror.NewUnimplemented("setting runID is not supported for StartExecution")

204 }

205

206 > currentExecutionReleaseFn, err := e.lockCurrentExecution( chasm_engine.go

207 > ctx,

208 > shardContext,

209 > namespace.ID(executionRef.NamespaceID),

210 > executionRef.BusinessID,

211 > archetypeID,

212 > )

213 > if err != nil {

214 return chasm.StartExecutionResult{}, err

215 }

216 > defer func() { chasm_engine.go

217 > currentExecutionReleaseFn(retErr)

218 > }()

219

220 > newExecutionParams, err := e.createNewExecution( chasm_engine.go

221 > ctx,

222 > shardContext,

223 > executionRef,

224 > archetypeID,

225 > startFn,

226 > options,

227 > )

228 > if err != nil {

229 return chasm.StartExecutionResult{}, err

230 }

231

232 > currentRunInfo, hasCurrentRun, err := e.persistAsBrandNew( chasm_engine.go

233 > ctx,

234 > shardContext,

235 > newExecutionParams,

236 > )

237 > if err != nil {

238 // Even though Created is false, it's not guaranteed the execution wasn't created.

239 // The persistence layer writes history events outside the main transaction, so on errors

241 return chasm.StartExecutionResult{}, err

242 }

243 > if !hasCurrentRun { chasm_engine.go

244 e.setContextMetadataFromMutableState(ctx, newExecutionParams.mutableState)

245 serializedRef, err := newExecutionParams.executionRef.Serialize(e.registry)

258 }

259

260 > return e.handleExecutionConflict( chasm_engine.go

261 > ctx,

262 > shardContext,

263 > newExecutionParams,

264 > currentRunInfo,

265 > options,

266 > )

267 }

268

778 func (e *ChasmEngine) constructTransitionOptions(

779 opts ...chasm.TransitionOption,

780 > ) chasm.TransitionOptions { chasm_engine.go

781 > options := defaultTransitionOptions

782 > for _, opt := range opts {

783 > opt(&options) chasm_engine.go

784 > }

785 > if options.RequestID == "" { chasm_engine.go

786 > options.RequestID = primitives.NewUUID().String() chasm_engine.go

787 > }

788 > return options chasm_engine.go

789 }

790

795 businessID string,

796 archetypeID chasm.ArchetypeID,

797 > ) (historyi.ReleaseWorkflowContextFunc, error) { chasm_engine.go

798 > currentExecutionReleaseFn, err := e.executionCache.GetOrCreateCurrentExecution(

799 > ctx,

800 > shardContext,

801 > namespaceID,

802 > businessID,

803 > archetypeID,

804 > locks.PriorityHigh,

805 > )

806 > if err != nil {

807 return nil, err

808 }

809

810 > return currentExecutionReleaseFn, nil chasm_engine.go

811 }

812

818 startFn func(chasm.MutableContext) (chasm.RootComponent, error),

819 options chasm.TransitionOptions,

820 > ) (newExecutionParams, error) { chasm_engine.go

821 > return e.createNewExecutionWithUpdate(

822 > ctx,

823 > shardContext,

824 > executionRef,

825 > archetypeID,

826 > startFn,

827 > nil,

828 > options,

829 > )

830 > }

831

832 func (e *ChasmEngine) createNewExecutionWithUpdate(

838 updateFn func(chasm.MutableContext, chasm.Component) error,

839 options chasm.TransitionOptions,

840 > ) (newExecutionParams, error) { chasm_engine.go

841 > executionRef.RunID = primitives.NewUUID().String()

842 >

843 > executionKey := executionRef.ExecutionKey

844 > nsRegistry := shardContext.GetNamespaceRegistry()

845 > nsEntry, err := nsRegistry.GetNamespaceByID(namespace.ID(executionKey.NamespaceID))

846 > if err != nil {

847 return newExecutionParams{}, err

848 }

849

850 > mutableState := workflow.NewMutableState( chasm_engine.go

851 > shardContext,

852 > shardContext.GetEventsCache(),

853 > shardContext.GetLogger(),

854 > nsEntry,

855 > executionKey.BusinessID,

856 > executionKey.RunID,

857 > shardContext.GetTimeSource().Now(),

858 > )

859 > mutableState.AttachRequestID(options.RequestID, enumspb.EVENT_TYPE_WORKFLOW_EXECUTION_STARTED, 0)

860 >

861 > chasmTree, ok := mutableState.ChasmTree().(*chasm.Node)

862 > if !ok {

863 return newExecutionParams{}, serviceerror.NewInternalf(

864 "CHASM tree implementation not properly wired up, encountered type: %T, expected type: %T",

868 }

869

870 > chasmContext := chasm.NewMutableContext(ctx, chasmTree) chasm_engine.go

871 >

872 > rootComponent, err := startFn(chasmContext)

873 > if err != nil {

874 return newExecutionParams{}, err

875 }

876 > if err := chasmTree.SetRootComponent(rootComponent); err != nil { chasm_engine.go

877 return newExecutionParams{}, err

878 }

879

880 > if updateFn != nil { chasm_engine.go

881 if err = updateFn(chasmContext, rootComponent); err != nil {

882 return newExecutionParams{}, err

884 }

885

886 > snapshot, events, err := mutableState.CloseTransactionAsSnapshot(ctx, historyi.TransactionPolicyActive) chasm_engine.go

887 > if err != nil {

888 return newExecutionParams{}, err

889 }

890 > if len(events) != 0 { chasm_engine.go

891 return newExecutionParams{}, serviceerror.NewInternal(

892 fmt.Sprintf("CHASM framework does not support events yet, found events for new run: %v", events),

894 }

895

896 > return newExecutionParams{ chasm_engine.go

897 > executionRef: executionRef,

898 > executionContext: workflow.NewContext(

899 > e.config,

900 > definition.NewWorkflowKey(

901 > executionKey.NamespaceID,

902 > executionKey.BusinessID,

903 > executionKey.RunID,

904 > ),

905 > archetypeID,

906 > shardContext.GetLogger(),

907 > shardContext.GetThrottledLogger(),

908 > shardContext.GetMetricsHandler(),

909 > ),

910 > mutableState: mutableState,

911 > snapshot: snapshot,

912 > events: events,

913 > }, nil

914 }

915

918 shardContext historyi.ShardContext,

919 newExecutionParams newExecutionParams,

920 > ) (currentExecutionInfo, bool, error) { chasm_engine.go

921 > err := newExecutionParams.executionContext.CreateWorkflowExecution(

922 > ctx,

923 > shardContext,

924 > persistence.CreateWorkflowModeBrandNew,

925 > "", // previousRunID

926 > 0, // prevlastWriteVersion

927 > newExecutionParams.mutableState,

928 > newExecutionParams.snapshot,

929 > newExecutionParams.events,

930 > historyi.TransactionPolicyActive,

931 > )

932 > if err == nil {

933 return currentExecutionInfo{}, false, nil

934 }

935

936 > currentRunConditionFailedError, ok := errors.AsType[*persistence.CurrentWorkflowConditionFailedError](err) chasm_engine.go

937 > if !ok || len(currentRunConditionFailedError.RunID) == 0 {

938 return currentExecutionInfo{}, false, err

939 }

940

941 > createRequestID := "" chasm_engine.go

942 > for requestID, info := range currentRunConditionFailedError.RequestIDs {

943 > if info.EventType == enumspb.EVENT_TYPE_WORKFLOW_EXECUTION_STARTED {

944 > createRequestID = requestID

945 > }

946 }

947 > return currentExecutionInfo{ chasm_engine.go

948 > createRequestID: createRequestID,

949 > CurrentWorkflowConditionFailedError: currentRunConditionFailedError,

950 > }, true, nil

951 }

952

972 currentRunInfo currentExecutionInfo,

973 options chasm.TransitionOptions,

974 > ) (chasm.StartExecutionResult, error) { chasm_engine.go

975 > // Check if this a retried request using requestID.

976 > if _, ok := currentRunInfo.RequestIDs[options.RequestID]; ok {

977 newExecutionParams.executionRef.RunID = currentRunInfo.RunID

978 serializedRef, err := newExecutionParams.executionRef.Serialize(e.registry)

987

988 // Verify failover version and make sure it won't go backwards even if the case of split brain.

989 > mutableState := newExecutionParams.mutableState chasm_engine.go

990 > nsEntry := mutableState.GetNamespaceEntry()

991 > if mutableState.GetCurrentVersion() < currentRunInfo.LastWriteVersion {

992 clusterMetadata := shardContext.GetClusterMetadata()

993 clusterName := clusterMetadata.ClusterNameForFailoverVersion(

1002 }

1003

1004 > switch currentRunInfo.State { chasm_engine.go

1005 > case enumsspb.WORKFLOW_EXECUTION_STATE_CREATED, enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING: chasm_engine.go

1006 > return e.handleConflictPolicy(ctx, shardContext, newExecutionParams, currentRunInfo, options.ConflictPolicy)

1007 case enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED:

1008 return e.handleReusePolicy(ctx, shardContext, newExecutionParams, currentRunInfo, options.ReusePolicy)

1020 currentRunInfo currentExecutionInfo,

1021 conflictPolicy chasm.BusinessIDConflictPolicy,

1022 > ) (chasm.StartExecutionResult, error) { chasm_engine.go

1023 > switch conflictPolicy {

1024 case chasm.BusinessIDConflictPolicyFail:

1025 return chasm.StartExecutionResult{}, chasm.NewExecutionAlreadyStartedErr(

1033 currentRunInfo.RunID,

1034 )

1035 > case chasm.BusinessIDConflictPolicyTerminateExisting: chasm_engine.go

1036 > // TODO: handle BusinessIDConflictPolicyTerminateExisting and update TestNewExecution_ConflictPolicy_TerminateExisting.

1037 > //

1038 > // Today's state-based replication logic can not existly handle this policy correctly

1039 > // (or any operation that close and starts a new run in one transaction).

1040 > // The termination and creation of new run can not be replicated transactionally.

1041 > //

1042 > // The main blocker is that state-based replication works on the current state,

1043 > // and we may have a chain of runs all created via TerminateExisting policy, meaning

1044 > // replication has to replicated all of them transactionally.

1045 > // We need a way to break this chain into consistent pieces and replicate them one by one.

1046 > return chasm.StartExecutionResult{}, serviceerror.NewUnimplemented("ID Conflict Policy Terminate Existing is not yet supported")

1047 case chasm.BusinessIDConflictPolicyUseExisting:

1048 existingExecutionRef := newExecutionParams.executionRef

1135 func (e *ChasmEngine) getShardContext(

1136 ref chasm.ComponentRef,

1137 > ) (historyi.ShardContext, error) { chasm_engine.go

1138 > return e.shardController.GetShardByID(

1139 > common.WorkflowIDToHistoryShard(

1140 > ref.NamespaceID,

1141 > ref.BusinessID,

1142 > e.config.NumberOfShards,

1143 > ),

1144 > )

1145 > }

1146

1147 // getExecutionLease returns shard context and mutable state for the chasm execution, with the lock

1269 ref chasm.ComponentRef,

1270 requestID string,

1271 > ) error { chasm_engine.go

1272 > if err == nil {

1273 return nil

1274 }

1275

1276 > if solErr, ok := errors.AsType[*persistence.ShardOwnershipLostError](err); ok { chasm_engine.go

1277 hostInfo := e.hostInfoProvider.HostInfo()

1278 e.logger.Error("chasm ShardOwnershipLostError", tag.Error(err), tag.RequestID(requestID))

1282 return serviceerrors.NewShardOwnershipLost("", hostInfo.GetAddress())

1283 }

1284 > if _, ok := errors.AsType[*persistence.AppendHistoryTimeoutError](err); ok { chasm_engine.go

1285 e.logger.Error("chasm AppendHistoryTimeoutError", tag.Error(err), tag.RequestID(requestID))

1286 return serviceerror.NewUnavailablef("append history timed out (request ID: %s)", requestID)

1287 }

1288 > if _, ok := errors.AsType[*persistence.WorkflowConditionFailedError](err); ok { chasm_engine.go

1289 e.logger.Error("chasm WorkflowConditionFailedError", tag.Error(err), tag.RequestID(requestID))

1290 return serviceerror.NewUnavailablef("workflow condition failed (request ID: %s)", requestID)

1291 }

1292 > if cwcfe, ok := errors.AsType[*persistence.CurrentWorkflowConditionFailedError](err); ok { chasm_engine.go

1293 e.logger.Error("chasm CurrentWorkflowConditionFailedError", tag.Error(err), tag.RequestID(requestID))

1294 return serviceerror.NewUnavailablef("current workflow condition failed for RunID %s (request ID: %s)", cwcfe.RunID, requestID)

1295 }

1296 > if _, ok := errors.AsType[*persistence.ConditionFailedError](err); ok { chasm_engine.go

1297 e.logger.Error("chasm ConditionFailedError", tag.Error(err), tag.RequestID(requestID))

1298 return serviceerror.NewUnavailablef("condition failed (request ID: %s)", requestID)

1299 }

1300 > if _, ok := errors.AsType[*persistence.TransactionSizeLimitError](err); ok { chasm_engine.go

1301 e.logger.Error("chasm TransactionSizeLimitError", tag.Error(err), tag.RequestID(requestID))

1302 return serviceerror.NewInvalidArgumentf("transaction size limit exceeded (request ID: %s)", requestID)

1303 }

1304 > if _, ok := errors.AsType[*persistence.TimeoutError](err); ok { chasm_engine.go

1305 e.logger.Error("chasm TimeoutError", tag.Error(err), tag.RequestID(requestID))

1306 return serviceerror.NewDeadlineExceededf("persistence operation timed out (request ID: %s)", requestID)

1307 }

1308

1309 > if _, ok := errors.AsType[*serviceerror.NotFound](err); !ok { chasm_engine.go

1310 > return err chasm_engine.go

1311 > }

1312

1313 return e.convertNotFoundError(err, ref)

go.temporal.io/server/service/history/shard/context_impl.go 182 covered LOC · 56 ranges

Open complete file

210 }

211

212 > func (s *ContextImpl) GetShardID() int32 { context_impl.go

213 > // constant from initialization, no need for locks

214 > return s.shardID

215 > }

216

217 func (s *ContextImpl) GetRangeID() int64 {

222 }

223

224 > func (s *ContextImpl) GetOwner() string { context_impl.go

225 > // constant from initialization, no need for locks

226 > return s.owner

227 > }

228

229 func (s *ContextImpl) GetExecutionManager() persistence.ExecutionManager {

313 }

314

315 > func (s *ContextImpl) CurrentVectorClock() *clockspb.VectorClock { context_impl.go

316 > s.rLock()

317 > defer s.rUnlock()

318 >

319 > nextTaskKey := s.taskKeyManager.peekTaskKey(tasks.CategoryTransfer)

320 > return vclock.NewVectorClock(s.clusterMetadata.GetClusterID(), s.shardID, nextTaskKey.TaskID)

321 > }

322

323 func (s *ContextImpl) GenerateTaskID() (int64, error) {

328 }

329

330 > func (s *ContextImpl) GetFinalizer() *finalizer.Finalizer { context_impl.go

331 > return s.finalizer

332 > }

333

334 > func (s *ContextImpl) GenerateTaskIDs(number int) ([]int64, error) { context_impl.go

335 > s.wLock()

336 > defer s.wUnlock()

337 >

338 > result := []int64{}

339 > for range number {

340 id, err := s.generateTaskIDLocked()

341 if err != nil {

344 result = append(result, id)

345 }

346 > return result, nil context_impl.go

347 }

348

537 ctx context.Context,

538 request *persistence.CreateWorkflowExecutionRequest,

539 > ) (*persistence.CreateWorkflowExecutionResponse, error) { context_impl.go

540 >

541 > // do not try to get namespace cache within shard lock

542 > namespaceID := namespace.ID(request.NewWorkflowSnapshot.ExecutionInfo.NamespaceId)

543 > namespaceEntry, err := s.GetNamespaceRegistry().GetNamespaceByID(namespaceID)

544 > if err != nil {

545 return nil, err

546 }

547

548 > if err := s.ioSemaphoreAcquire(ctx); err != nil { context_impl.go

549 return nil, err

550 }

551 > defer s.ioSemaphoreRelease() context_impl.go

552 >

553 > s.wLock()

554 >

555 > // timeout check should be done within the shard lock, in case of shard lock contention

556 > ctx, cancel, err := s.newDetachedContext(ctx)

557 > if err != nil {

558 s.wUnlock()

559 return nil, err

560 }

561 > defer cancel() context_impl.go

562 >

563 > if err := s.errorByState(); err != nil {

564 s.wUnlock()

565 return nil, err

566 }

567

568 > if err := s.errorByNamespaceStateLocked(namespaceEntry.Name(), request.NewWorkflowSnapshot.ExecutionInfo.WorkflowId); err != nil { context_impl.go

569 s.wUnlock()

570 return nil, err

571 }

572

573 > requestCompletionFn, err := s.taskKeyManager.setAndTrackTaskKeys( context_impl.go

574 > request.NewWorkflowSnapshot.Tasks,

575 > )

576 > if err != nil {

577 s.wUnlock()

578 return nil, err

579 }

580 > s.updateCloseTaskIDs(request.NewWorkflowSnapshot.ExecutionInfo, request.NewWorkflowSnapshot.Tasks) context_impl.go

581 >

582 > currentRangeID := s.getRangeIDLocked()

583 > request.RangeID = currentRangeID

584 >

585 > s.wUnlock()

586 > resp, err := s.executionManager.CreateWorkflowExecution(ctx, request)

587 > requestCompletionFn(err)

588 >

589 > if err = s.handleWriteError(request.RangeID, err); err != nil {

590 > return nil, err context_impl.go

591 > }

592 return resp, nil

593 }

655 }

656

657 > func (s *ContextImpl) updateCloseTaskIDs(executionInfo *persistencespb.WorkflowExecutionInfo, tasksByCategory map[tasks.Category][]tasks.Task) { context_impl.go

658 > for _, t := range tasksByCategory[tasks.CategoryTransfer] {

659 if t.GetType() == enumsspb.TASK_TYPE_TRANSFER_CLOSE_EXECUTION {

660 executionInfo.CloseTransferTaskId = t.GetTaskID()

662 }

663 }

664 > for _, t := range tasksByCategory[tasks.CategoryVisibility] { context_impl.go

665 if t.GetType() == enumsspb.TASK_TYPE_VISIBILITY_CLOSE_EXECUTION ||

666 t.GetType() == enumsspb.TASK_TYPE_CHASM {

1100 }

1101

1102 > func (s *ContextImpl) GetConfig() *configs.Config { context_impl.go

1103 > // constant from initialization, no need for locks

1104 > return s.config

1105 > }

1106

1107 > func (s *ContextImpl) GetEventsCache() events.Cache { context_impl.go

1108 > // constant from initialization (except for tests), no need for locks

1109 > return s.eventsCache

1110 > }

1111

1112 > func (s *ContextImpl) GetLogger() log.Logger { context_impl.go

1113 > // constant from initialization, no need for locks

1114 > return s.contextTaggedLogger

1115 > }

1116

1117 > func (s *ContextImpl) GetThrottledLogger() log.Logger { context_impl.go

1118 > // constant from initialization, no need for locks

1119 > return s.throttledLogger

1120 > }

1121

1122 > func (s *ContextImpl) getRangeIDLocked() int64 { context_impl.go

1123 > return s.shardInfo.GetRangeId()

1124 > }

1125

1126 > func (s *ContextImpl) errorByState() error { context_impl.go

1127 > s.stateLock.Lock()

1128 > defer s.stateLock.Unlock()

1129 >

1130 > switch s.state {

1131 case contextStateInitialized, contextStateAcquiring:

1132 return ErrShardStatusUnknown

1133 > case contextStateAcquired: context_impl.go

1134 > return nil

1135 case contextStateStopping, contextStateStopped:

1136 return s.newShardClosedErrorWithShardID()

1143 namespaceName namespace.Name,

1144 workflowID string,

1145 > ) error { context_impl.go

1146 > if s.handoverTracker.IsInHandover(namespaceName, workflowID) {

1147 return consts.ErrNamespaceHandover

1148 }

1149 > return nil context_impl.go

1150 }

1151

1384 requestRangeID int64,

1385 err error,

1386 > ) error { context_impl.go

1387 > s.wLock()

1388 > defer s.wUnlock()

1389 >

1390 > return s.handleWriteErrorLocked(requestRangeID, err)

1391 > }

1392

1393 func (s *ContextImpl) handleWriteErrorLocked(

1394 requestRangeID int64,

1395 err error,

1396 > ) error { context_impl.go

1397 >

1398 > if requestRangeID != s.getRangeIDLocked() {

1399 return err

1400 }

1401

1402 > if valid := s.IsValid(); !valid { context_impl.go

1403 return err

1404 }

1405 > switch err.(type) { context_impl.go

1406 case nil:

1407 // Persistence success: update max read level

1419 *serviceerror.ResourceExhausted,

1420 *serviceerror.NotFound,

1421 > *serviceerror.NamespaceNotFound: context_impl.go

1422 > // Persistence failure that means the write was definitely not committed:

1423 > // No special handling required for these errors.

1424 > return err

1425

1426 case *persistence.ShardOwnershipLostError:

1490 }

1491

1492 > func (s *ContextImpl) IsValid() bool { context_impl.go

1493 > s.stateLock.Lock()

1494 > defer s.stateLock.Unlock()

1495 > return s.state < contextStateStopping

1496 > }

1497

1498 func (s *ContextImpl) GetLifecycleContext() context.Context {

1506 }

1507

1508 > func (s *ContextImpl) wLock() { context_impl.go

1509 > handler := s.metricsHandler.WithTags(metrics.OperationTag(metrics.ShardInfoScope))

1510 > metrics.LockRequests.With(handler).Record(1)

1511 > startTime := time.Now().UTC()

1512 > defer func() { metrics.LockLatency.With(handler).Record(time.Since(startTime)) }()

1513

1514 > s.rwLock.Lock() context_impl.go

1515 }

1516

1517 > func (s *ContextImpl) rLock() { context_impl.go

1518 > handler := s.metricsHandler.WithTags(metrics.OperationTag(metrics.ShardInfoScope))

1519 > metrics.LockRequests.With(handler).Record(1)

1520 > startTime := time.Now().UTC()

1521 > defer func() { metrics.LockLatency.With(handler).Record(time.Since(startTime)) }()

1522

1523 > s.rwLock.RLock() context_impl.go

1524 }

1525

1526 > func (s *ContextImpl) wUnlock() { context_impl.go

1527 > s.rwLock.Unlock()

1528 > }

1529

1530 > func (s *ContextImpl) rUnlock() { context_impl.go

1531 > s.rwLock.RUnlock()

1532 > }

1533

1534 func (s *ContextImpl) ioSemaphoreAcquire(

1535 ctx context.Context,

1536 > ) (retErr error) { context_impl.go

1537 > priority := locks.PriorityHigh

1538 > callerInfo := headers.GetCallerInfo(ctx)

1539 > if callerInfo.CallerType == headers.CallerTypePreemptable {

1540 priority = locks.PriorityLow

1541 }

1542

1543 > handler := s.metricsHandler.WithTags(metrics.OperationTag(metrics.ShardInfoScope), metrics.PriorityTag(priority)) context_impl.go

1544 > metrics.SemaphoreRequests.With(handler).Record(1)

1545 > startTime := time.Now().UTC()

1546 > defer func() {

1547 > metrics.SemaphoreLatency.With(handler).Record(time.Since(startTime))

1548 > if retErr != nil {

1549 metrics.SemaphoreFailures.With(handler).Record(1)

1550 }

1551 }()

1552

1553 > return s.ioSemaphore.Acquire(ctx, priority, 1) context_impl.go

1554 }

1555

1556 > func (s *ContextImpl) ioSemaphoreRelease() { context_impl.go

1557 > s.ioSemaphore.Release(1)

1558 > }

1559

1560 func (s *ContextImpl) transition(request contextRequest) error {

2212 }

2213

2214 > func (s *ContextImpl) GetMetricsHandler() metrics.Handler { context_impl.go

2215 > return s.metricsHandler

2216 > }

2217

2218 > func (s *ContextImpl) GetTimeSource() cclock.TimeSource { context_impl.go

2219 > return s.timeSource

2220 > }

2221

2222 > func (s *ContextImpl) GetNamespaceRegistry() namespace.Registry { context_impl.go

2223 > return s.namespaceRegistry

2224 > }

2225

2226 func (s *ContextImpl) GetSearchAttributesProvider() searchattribute.Provider {

2232 }

2233

2234 > func (s *ContextImpl) GetClusterMetadata() cluster.Metadata { context_impl.go

2235 > return s.clusterMetadata

2236 > }

2237

2238 > func (s *ContextImpl) GetArchivalMetadata() archiver.ArchivalMetadata { context_impl.go

2239 > return s.archivalMetadata

2240 > }

2241

2242 > func (s *ContextImpl) StateMachineRegistry() *hsm.Registry { context_impl.go

2243 > return s.stateMachineRegistry

2244 > }

2245

2246 > func (s *ContextImpl) ChasmRegistry() *chasm.Registry { context_impl.go

2247 > return s.chasmRegistry

2248 > }

2249

2250 func (s *ContextImpl) ChasmWorkflowRegistry() *chasmworkflow.Registry {

2252 }

2253

2254 > func (s *ContextImpl) EndpointRegistry() chasm.EndpointRegistry { context_impl.go

2255 > return s.endpointRegistry

2256 > }

2257

2258 > func (s *ContextImpl) BusinessIDReuseRateLimiter(namespaceID namespace.ID, businessID string, archetypeID chasm.ArchetypeID) quotas.RateLimiter { context_impl.go

2259 > rps := s.config.BusinessIDReuseRate(namespaceID.String())

2260 > if rps <= 0 {

2261 > return nil context_impl.go

2262 > }

2263 burst := max(1, int(float64(rps)*s.config.BusinessIDReuseBurstRatio(namespaceID.String())))

2264 key := namespaceID.String() + "/" + businessID + "/" + strconv.Itoa(int(archetypeID))

2303 func (s *ContextImpl) newDetachedContext(

2304 ctx context.Context,

2305 > ) (context.Context, context.CancelFunc, error) { context_impl.go

2306 > if err := ctx.Err(); err != nil {

2307 return nil, nil, err

2308 }

2309

2310 > detachedContext := rpc.CopyContextValues(s.lifecycleCtx, ctx) context_impl.go

2311 >

2312 > var cancel context.CancelFunc

2313 > deadline, ok := ctx.Deadline()

2314 > if ok {

2315 timeout := max(deadline.Sub(s.GetTimeSource().Now()), minContextTimeout)

2316 detachedContext, cancel = context.WithTimeout(detachedContext, timeout)

2317 > } else { context_impl.go

2318 > cancel = func() {} context_impl.go

2319 }

2320

2321 > return detachedContext, cancel, nil context_impl.go

2322 }

2323

go.temporal.io/server/api/persistence/v1/executions.pb.go 141 covered LOC · 30 ranges

Open complete file

83 }

84

85 > func (x *ShardInfo) GetShardId() int32 { executions.pb.go

86 > if x != nil {

87 > return x.ShardId

88 > }

89 return 0

90 }

91

92 > func (x *ShardInfo) GetRangeId() int64 { executions.pb.go

93 > if x != nil {

94 > return x.RangeId

95 > }

96 return 0

97 }

98

99 > func (x *ShardInfo) GetOwner() string { executions.pb.go

100 > if x != nil {

101 > return x.Owner

102 > }

103 return ""

104 }

393 func (*WorkflowExecutionInfo) ProtoMessage() {}

394

395 > func (x *WorkflowExecutionInfo) ProtoReflect() protoreflect.Message { executions.pb.go

396 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[1]

397 > if x != nil {

398 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) executions.pb.go

399 > if ms.LoadMessageInfo() == nil {

400 > ms.StoreMessageInfo(mi)

401 > }

402 > return ms

403 }

404 return mi.MessageOf(x)

1142 }

1143

1144 > func (x *WorkflowExecutionInfo) GetTimeSkippingInfo() *TimeSkippingInfo { executions.pb.go

1145 > if x != nil {

1146 > return x.TimeSkippingInfo

1147 > }

1148 return nil

1149 }

1199 func (*TimeSkippingInfo) ProtoMessage() {}

1200

1201 > func (x *TimeSkippingInfo) ProtoReflect() protoreflect.Message { executions.pb.go

1202 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[2]

1203 > if x != nil {

1204 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1205 if ms.LoadMessageInfo() == nil {

1208 return ms

1209 }

1210 > return mi.MessageOf(x) executions.pb.go

1211 }

1212

1333 func (*LastNotifiedTargetVersion) ProtoMessage() {}

1334

1335 > func (x *LastNotifiedTargetVersion) ProtoReflect() protoreflect.Message { executions.pb.go

1336 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[4]

1337 > if x != nil {

1338 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1339 if ms.LoadMessageInfo() == nil {

1342 return ms

1343 }

1344 > return mi.MessageOf(x) executions.pb.go

1345 }

1346

1390 func (*ExecutionStats) ProtoMessage() {}

1391

1392 > func (x *ExecutionStats) ProtoReflect() protoreflect.Message { executions.pb.go

1393 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[5]

1394 > if x != nil {

1395 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1396 if ms.LoadMessageInfo() == nil {

1399 return ms

1400 }

1401 > return mi.MessageOf(x) executions.pb.go

1402 }

1403

1463 func (*WorkflowExecutionState) ProtoMessage() {}

1464

1465 > func (x *WorkflowExecutionState) ProtoReflect() protoreflect.Message { executions.pb.go

1466 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[6]

1467 > if x != nil {

1468 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) executions.pb.go

1469 > if ms.LoadMessageInfo() == nil {

1470 > ms.StoreMessageInfo(mi)

1471 > }

1472 > return ms

1473 }

1474 return mi.MessageOf(x)

1494 }

1495

1496 > func (x *WorkflowExecutionState) GetState() v1.WorkflowExecutionState { executions.pb.go

1497 > if x != nil {

1498 > return x.State executions.pb.go

1499 > }

1500 return v1.WorkflowExecutionState(0)

1501 }

1557 func (*RequestIDInfo) ProtoMessage() {}

1558

1559 > func (x *RequestIDInfo) ProtoReflect() protoreflect.Message { executions.pb.go

1560 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[7]

1561 > if x != nil {

1562 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) executions.pb.go

1563 > if ms.LoadMessageInfo() == nil {

1564 > ms.StoreMessageInfo(mi)

1565 > }

1566 > return ms

1567 }

1568 > return mi.MessageOf(x) executions.pb.go

1569 }

1570

2889 func (*ActivityInfo) ProtoMessage() {}

2890

2891 > func (x *ActivityInfo) ProtoReflect() protoreflect.Message { executions.pb.go

2892 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[17]

2893 > if x != nil {

2894 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) executions.pb.go

2895 > if ms.LoadMessageInfo() == nil {

2896 > ms.StoreMessageInfo(mi)

2897 > }

2898 > return ms

2899 }

2900 return mi.MessageOf(x)

4336 func (*ResetChildInfo) ProtoMessage() {}

4337

4338 > func (x *ResetChildInfo) ProtoReflect() protoreflect.Message { executions.pb.go

4339 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[28]

4340 > if x != nil {

4341 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4342 if ms.LoadMessageInfo() == nil {

4345 return ms

4346 }

4347 > return mi.MessageOf(x) executions.pb.go

4348 }

4349

4387 func (*WorkflowPauseInfo) ProtoMessage() {}

4388

4389 > func (x *WorkflowPauseInfo) ProtoReflect() protoreflect.Message { executions.pb.go

4390 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[29]

4391 > if x != nil {

4392 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4393 if ms.LoadMessageInfo() == nil {

4396 return ms

4397 }

4398 > return mi.MessageOf(x) executions.pb.go

4399 }

4400

4503 func (*ActivityInfo_UseWorkflowBuildIdInfo) ProtoMessage() {}

4504

4505 > func (x *ActivityInfo_UseWorkflowBuildIdInfo) ProtoReflect() protoreflect.Message { executions.pb.go

4506 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[39]

4507 > if x != nil {

4508 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4509 if ms.LoadMessageInfo() == nil {

4512 return ms

4513 }

4514 > return mi.MessageOf(x) executions.pb.go

4515 }

4516

4561 func (*ActivityInfo_PauseInfo) ProtoMessage() {}

4562

4563 > func (x *ActivityInfo_PauseInfo) ProtoReflect() protoreflect.Message { executions.pb.go

4564 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[40]

4565 > if x != nil {

4566 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4567 if ms.LoadMessageInfo() == nil {

4570 return ms

4571 }

4572 > return mi.MessageOf(x) executions.pb.go

4573 }

4574

5706 }

5707

5708 > func init() { file_temporal_server_api_persistence_v1_executions_proto_init() } executions.pb.go

5709 > func file_temporal_server_api_persistence_v1_executions_proto_init() {

5710 > if File_temporal_server_api_persistence_v1_executions_proto != nil {

5711 > return

5712 > }

5713 > file_temporal_server_api_persistence_v1_chasm_proto_init()

5714 > file_temporal_server_api_persistence_v1_hsm_proto_init()

5715 > file_temporal_server_api_persistence_v1_queues_proto_init()

5716 > file_temporal_server_api_persistence_v1_update_proto_init()

5717 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[1].OneofWrappers = []any{

5718 > (*WorkflowExecutionInfo_LastWorkflowTaskFailureCause)(nil),

5719 > (*WorkflowExecutionInfo_LastWorkflowTaskTimedOutType)(nil),

5720 > }

5721 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[8].OneofWrappers = []any{

5722 > (*TransferTaskInfo_CloseExecutionTaskDetails_)(nil),

5723 > (*TransferTaskInfo_ChasmTaskInfo)(nil),

5724 > }

5725 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[10].OneofWrappers = []any{

5726 > (*VisibilityTaskInfo_ChasmTaskInfo)(nil),

5727 > }

5728 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[11].OneofWrappers = []any{

5729 > (*TimerTaskInfo_ChasmTaskInfo)(nil),

5730 > }

5731 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[13].OneofWrappers = []any{

5732 > (*OutboundTaskInfo_StateMachineInfo)(nil),

5733 > (*OutboundTaskInfo_ChasmTaskInfo)(nil),

5734 > (*OutboundTaskInfo_WorkerCommandsTask)(nil),

5735 > }

5736 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[17].OneofWrappers = []any{

5737 > (*ActivityInfo_UseWorkflowBuildIdInfo_)(nil),

5738 > (*ActivityInfo_LastIndependentlyAssignedBuildId)(nil),

5739 > }

5740 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[23].OneofWrappers = []any{

5741 > (*Callback_Nexus_)(nil),

5742 > (*Callback_Hsm)(nil),

5743 > }

5744 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[40].OneofWrappers = []any{

5745 > (*ActivityInfo_PauseInfo_Manual_)(nil),

5746 > (*ActivityInfo_PauseInfo_RuleId)(nil),

5747 > }

5748 > file_temporal_server_api_persistence_v1_executions_proto_msgTypes[46].OneofWrappers = []any{

5749 > (*CallbackInfo_Trigger_WorkflowClosed)(nil),

5750 > }

5751 > type x struct{}

5752 > out := protoimpl.TypeBuilder{

5753 > File: protoimpl.DescBuilder{

5754 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

5755 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_executions_proto_rawDesc), len(file_temporal_server_api_persistence_v1_executions_proto_rawDesc)),

5756 > NumEnums: 0,

5757 > NumMessages: 47,

5758 > NumExtensions: 0,

5759 > NumServices: 0,

5760 > },

5761 > GoTypes: file_temporal_server_api_persistence_v1_executions_proto_goTypes,

5762 > DependencyIndexes: file_temporal_server_api_persistence_v1_executions_proto_depIdxs,

5763 > MessageInfos: file_temporal_server_api_persistence_v1_executions_proto_msgTypes,

5764 > }.Build()

5765 > File_temporal_server_api_persistence_v1_executions_proto = out.File

5766 > file_temporal_server_api_persistence_v1_executions_proto_goTypes = nil

5767 > file_temporal_server_api_persistence_v1_executions_proto_depIdxs = nil

5768 }

go.temporal.io/server/common/resourcetest/test_resource.go 132 covered LOC · 13 ranges

Open complete file

95

96 // NewTest returns a new test resource instance

97 > func NewTest(controller *gomock.Controller, serviceName primitives.ServiceName) *Test { test_resource.go

98 > logger := log.NewTestLogger()

99 >

100 > frontendClient := workflowservicemock.NewMockWorkflowServiceClient(controller)

101 > matchingClient := matchingservicemock.NewMockMatchingServiceClient(controller)

102 > historyClient := historyservicemock.NewMockHistoryServiceClient(controller)

103 > remoteFrontendClient := workflowservicemock.NewMockWorkflowServiceClient(controller)

104 > remoteAdminClient := adminservicemock.NewMockAdminServiceClient(controller)

105 > clusterMetadataManager := persistence.NewMockClusterMetadataManager(controller)

106 > clientBean := client.NewMockBean(controller)

107 > clientBean.EXPECT().GetFrontendClient().Return(frontendClient).AnyTimes()

108 > clientBean.EXPECT().GetMatchingClient(gomock.Any()).Return(matchingClient, nil).AnyTimes()

109 > clientBean.EXPECT().GetHistoryClient().Return(historyClient).AnyTimes()

110 > clientBean.EXPECT().GetRemoteAdminClient(gomock.Any()).Return(remoteAdminClient, nil).AnyTimes()

111 > clientBean.EXPECT().GetRemoteFrontendClient(gomock.Any()).Return(nil, remoteFrontendClient, nil).AnyTimes()

112 > clientFactory := client.NewMockFactory(controller)

113 >

114 > metadataMgr := persistence.NewMockMetadataManager(controller)

115 > taskMgr := persistence.NewMockTaskManager(controller)

116 > shardMgr := persistence.NewMockShardManager(controller)

117 > executionMgr := persistence.NewMockExecutionManager(controller)

118 > executionMgr.EXPECT().GetHistoryBranchUtil().Return(persistence.NewHistoryBranchUtil(serialization.NewSerializer())).AnyTimes()

119 > namespaceReplicationQueue := persistence.NewMockNamespaceReplicationQueue(controller)

120 > nexusEndpointMgr := persistence.NewMockNexusEndpointManager(controller)

121 >

122 > membershipMonitor := membership.NewMockMonitor(controller)

123 > hostInfoProvider := membership.NewMockHostInfoProvider(controller)

124 > frontendServiceResolver := membership.NewMockServiceResolver(controller)

125 > matchingServiceResolver := membership.NewMockServiceResolver(controller)

126 > historyServiceResolver := membership.NewMockServiceResolver(controller)

127 > workerServiceResolver := membership.NewMockServiceResolver(controller)

128 > membershipMonitor.EXPECT().GetResolver(primitives.FrontendService).Return(frontendServiceResolver, nil).AnyTimes()

129 > membershipMonitor.EXPECT().GetResolver(primitives.InternalFrontendService).Return(nil, membership.ErrUnknownService).AnyTimes()

130 > membershipMonitor.EXPECT().GetResolver(primitives.MatchingService).Return(matchingServiceResolver, nil).AnyTimes()

131 > membershipMonitor.EXPECT().GetResolver(primitives.HistoryService).Return(historyServiceResolver, nil).AnyTimes()

132 > membershipMonitor.EXPECT().GetResolver(primitives.WorkerService).Return(workerServiceResolver, nil).AnyTimes()

133 > membershipMonitor.EXPECT().WaitUntilInitialized(gomock.Any()).Return(nil).AnyTimes()

134 >

135 > scope := tally.NewTestScope("test", nil)

136 > metricsHandler := metrics.NewTallyMetricsHandler(metrics.ClientConfig{}, scope).WithTags(

137 > metrics.ServiceNameTag(serviceName),

138 > )

139 >

140 > return &Test{

141 > MetricsScope: scope,

142 > ClusterMetadata: cluster.NewMockMetadata(controller),

143 > SearchAttributesProvider: searchattribute.NewMockProvider(controller),

144 > SearchAttributesManager: searchattribute.NewMockManager(controller),

145 > SearchAttributesMapperProvider: searchattribute.NewMockMapperProvider(controller),

146 >

147 > // other common resources

148 >

149 > NamespaceCache: namespace.NewMockRegistry(controller),

150 > TimeSource: clock.NewRealTimeSource(),

151 > PayloadSerializer: serialization.NewSerializer(),

152 > MetricsHandler: metricsHandler,

153 > ArchivalMetadata: archiver.NewMetadataMock(controller),

154 > ArchiverProvider: provider.NewMockArchiverProvider(controller),

155 >

156 > // membership infos

157 >

158 > MembershipMonitor: membershipMonitor,

159 > HostInfoProvider: hostInfoProvider,

160 > FrontendServiceResolver: frontendServiceResolver,

161 > MatchingServiceResolver: matchingServiceResolver,

162 > HistoryServiceResolver: historyServiceResolver,

163 > WorkerServiceResolver: workerServiceResolver,

164 >

165 > // internal services clients

166 >

167 > SDKClientFactory: sdk.NewMockClientFactory(controller),

168 > FrontendClient: frontendClient,

169 > MatchingClient: matchingClient,

170 > HistoryClient: historyClient,

171 > RemoteAdminClient: remoteAdminClient,

172 > RemoteFrontendClient: remoteFrontendClient,

173 > ClientBean: clientBean,

174 > ClientFactory: clientFactory,

175 > ESClient: esclient.NewMockClient(controller),

176 > VisibilityManager: manager.NewMockVisibilityManager(controller),

177 >

178 > // persistence clients

179 >

180 > MetadataMgr: metadataMgr,

181 > ClusterMetadataMgr: clusterMetadataManager,

182 > TaskMgr: taskMgr,

183 > NamespaceReplicationQueue: namespaceReplicationQueue,

184 > ShardMgr: shardMgr,

185 > ExecutionMgr: executionMgr,

186 > NexusEndpointManager: nexusEndpointMgr,

187 >

188 > // logger

189 >

190 > Logger: logger,

191 > }

192 > }

193

194 // Start for testing

218

219 // GetClusterMetadata for testing

220 > func (t *Test) GetClusterMetadata() cluster.Metadata { test_resource.go

221 > return t.ClusterMetadata

222 > }

223

224 // GetClusterMetadata for testing

230

231 // GetNamespaceRegistry for testing

232 > func (t *Test) GetNamespaceRegistry() namespace.Registry { test_resource.go

233 > return t.NamespaceCache

234 > }

235

236 // GetTimeSource for testing

240

241 // GetPayloadSerializer for testing

242 > func (t *Test) GetPayloadSerializer() serialization.Serializer { test_resource.go

243 > return t.PayloadSerializer

244 > }

245

246 // GetMetricsHandler for testing

250

251 // GetArchivalMetadata for testing

252 > func (t *Test) GetArchivalMetadata() archiver.ArchivalMetadata { test_resource.go

253 > return t.ArchivalMetadata

254 > }

255

256 // GetArchiverProvider for testing

267

268 // GetHostInfoProvider for testing

269 > func (t *Test) GetHostInfoProvider() membership.HostInfoProvider { test_resource.go

270 > return t.HostInfoProvider

271 > }

272

273 // GetFrontendServiceResolver for testing

319

320 // GetHistoryClient for testing

321 > func (t *Test) GetHistoryClient() historyservice.HistoryServiceClient { test_resource.go

322 > return t.HistoryClient

323 > }

324

325 // GetRemoteAdminClient for testing

338

339 // GetClientBean for testing

340 > func (t *Test) GetClientBean() client.Bean { test_resource.go

341 > return t.ClientBean

342 > }

343

344 // GetClientFactory for testing

371

372 // GetShardManager for testing

373 > func (t *Test) GetShardManager() persistence.ShardManager { test_resource.go

374 > return t.ShardMgr

375 > }

376

377 // GetExecutionManager for testing

383

384 // GetLogger for testing

385 > func (t *Test) GetLogger() log.Logger { test_resource.go

386 > return t.Logger

387 > }

388

389 // GetThrottledLogger for testing

390 > func (t *Test) GetThrottledLogger() log.Logger { test_resource.go

391 > return t.Logger

392 > }

393

394 // GetGRPCListener for testing

397 }

398

399 > func (t *Test) GetSearchAttributesProvider() searchattribute.Provider { test_resource.go

400 > return t.SearchAttributesProvider

401 > }

402

403 func (t *Test) GetSearchAttributesManager() searchattribute.Manager {

405 }

406

407 > func (t *Test) GetSearchAttributesMapperProvider() searchattribute.MapperProvider { test_resource.go

408 > return t.SearchAttributesMapperProvider

409 > }

go.temporal.io/server/chasm/search_attribute.go 121 covered LOC · 18 ranges

Open complete file

136 }

137

138 > func newSearchAttributeFieldBool(index int) SearchAttributeFieldBool { search_attribute.go

139 > return SearchAttributeFieldBool{

140 > field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_BOOL, index),

141 > }

142 > }

143

144 // SearchAttributeFieldDateTime is a search attribute field for a datetime value.

147 }

148

149 > func newSearchAttributeFieldDateTime(index int) SearchAttributeFieldDateTime { search_attribute.go

150 > return SearchAttributeFieldDateTime{

151 > field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_DATETIME, index),

152 > }

153 > }

154

155 // SearchAttributeFieldInt is a search attribute field for an integer value.

158 }

159

160 > func newSearchAttributeFieldInt(index int) SearchAttributeFieldInt { search_attribute.go

161 > return SearchAttributeFieldInt{

162 > field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_INT, index),

163 > }

164 > }

165

166 // SearchAttributeFieldDouble is a search attribute field for a double value.

169 }

170

171 > func newSearchAttributeFieldDouble(index int) SearchAttributeFieldDouble { search_attribute.go

172 > return SearchAttributeFieldDouble{

173 > field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_DOUBLE, index),

174 > }

175 > }

176

177 // SearchAttributeFieldKeyword is a search attribute field for a keyword value.

180 }

181

182 > func newSearchAttributeFieldKeyword(index int) SearchAttributeFieldKeyword { search_attribute.go

183 > return SearchAttributeFieldKeyword{

184 > field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_KEYWORD, index),

185 > }

186 > }

187

188 > func newSearchAttributeFieldLowCardinalityKeyword(index int) SearchAttributeFieldKeyword { search_attribute.go

189 > return SearchAttributeFieldKeyword{

190 > field: fmt.Sprintf("%s%s%02d", sadefs.ReservedPrefix, "LowCardinalityKeyword", index),

191 > }

192 > }

193

194 // SearchAttributeFieldKeywordList is a search attribute field for a keyword list value.

197 }

198

199 > func newSearchAttributeFieldKeywordList(index int) SearchAttributeFieldKeywordList { search_attribute.go

200 > return SearchAttributeFieldKeywordList{

201 > field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_KEYWORD_LIST, index),

202 > }

203 > }

204

205 // SearchAttributeFieldText is a search attribute field for a text value.

214 }

215

216 > func resolveFieldName(valueType enumspb.IndexedValueType, index int) string { search_attribute.go

217 > // Columns are named like TemporalBool01, TemporalDatetime01, TemporalDouble01, TemporalInt01.

218 > return fmt.Sprintf("%s%s%02d", sadefs.ReservedPrefix, valueType.String(), index)

219 > }

220

221 > func (s searchAttributeDefinition) definition() searchAttributeDefinition { search_attribute.go

222 > return s

223 > }

224

225 // SearchAttributeBool is a search attribute for a boolean value.

229

230 // NewSearchAttributeBool creates a new boolean search attribute given a predefined chasm field

231 > func NewSearchAttributeBool(alias string, boolField SearchAttributeFieldBool) SearchAttributeBool { search_attribute.go

232 > return SearchAttributeBool{

233 > searchAttributeDefinition: searchAttributeDefinition{

234 > alias: alias,

235 > field: boolField.field,

236 > valueType: enumspb.INDEXED_VALUE_TYPE_BOOL,

237 > },

238 > }

239 > }

240

241 > func newSearchAttributeBoolByField(field string) SearchAttributeBool { search_attribute.go

242 > return SearchAttributeBool{

243 > searchAttributeDefinition: searchAttributeDefinition{

244 > alias: field,

245 > field: field,

246 > valueType: enumspb.INDEXED_VALUE_TYPE_BOOL,

247 > },

248 > }

249 > }

250

251 // Value sets the boolean value of the search attribute.

252 > func (s SearchAttributeBool) Value(value bool) SearchAttributeKeyValue { search_attribute.go

253 > return SearchAttributeKeyValue{

254 > Alias: s.alias,

255 > Field: s.field,

256 > Value: VisibilityValueBool(value),

257 > }

258 > }

259

260 func (s SearchAttributeBool) typeMarker(_ bool) {}

266

267 // NewSearchAttributeDateTime creates a new date time search attribute given a predefined chasm field

268 > func NewSearchAttributeDateTime(alias string, datetimeField SearchAttributeFieldDateTime) SearchAttributeDateTime { search_attribute.go

269 > return SearchAttributeDateTime{

270 > searchAttributeDefinition: searchAttributeDefinition{

271 > alias: alias,

272 > field: datetimeField.field,

273 > valueType: enumspb.INDEXED_VALUE_TYPE_DATETIME,

274 > },

275 > }

276 > }

277

278 > func newSearchAttributeDateTimeByField(field string) SearchAttributeDateTime { search_attribute.go

279 > return SearchAttributeDateTime{

280 > searchAttributeDefinition: searchAttributeDefinition{

281 > alias: field,

282 > field: field,

283 > valueType: enumspb.INDEXED_VALUE_TYPE_DATETIME,

284 > },

285 > }

286 > }

287

288 // Value sets the date time value of the search attribute.

303

304 // NewSearchAttributeInt creates a new integer search attribute given a predefined chasm field

305 > func NewSearchAttributeInt(alias string, intField SearchAttributeFieldInt) SearchAttributeInt { search_attribute.go

306 > return SearchAttributeInt{

307 > searchAttributeDefinition: searchAttributeDefinition{

308 > alias: alias,

309 > field: intField.field,

310 > valueType: enumspb.INDEXED_VALUE_TYPE_INT,

311 > },

312 > }

313 > }

314

315 // Value sets the integer value of the search attribute.

367

368 // NewSearchAttributeKeyword creates a new keyword search attribute given a predefined chasm field

369 > func NewSearchAttributeKeyword(alias string, keywordField SearchAttributeFieldKeyword) SearchAttributeKeyword { search_attribute.go

370 > return SearchAttributeKeyword{

371 > searchAttributeDefinition: searchAttributeDefinition{

372 > alias: alias,

373 > field: keywordField.field,

374 > valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD,

375 > },

376 > }

377 > }

378

379 > func newSearchAttributeKeywordByField(field string) SearchAttributeKeyword { search_attribute.go

380 > return SearchAttributeKeyword{

381 > searchAttributeDefinition: searchAttributeDefinition{

382 > alias: field,

383 > field: field,

384 > valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD,

385 > },

386 > }

387 > }

388

389 // Value sets the string value of the search attribute.

414 }

415

416 > func newSearchAttributeKeywordListByField(field string) SearchAttributeKeywordList { search_attribute.go

417 > return SearchAttributeKeywordList{

418 > searchAttributeDefinition: searchAttributeDefinition{

419 > alias: field,

420 > field: field,

421 > valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD_LIST,

422 > },

423 > }

424 > }

425

426 // Value sets the string list value of the search attribute.

go.temporal.io/server/common/cache/lru.go 120 covered LOC · 35 ranges

Open complete file

126 }

127

128 > func (entry *entryImpl) Size() int { lru.go

129 > return entry.size

130 > }

131

132 func (entry *entryImpl) CreateTime() time.Time {

135

136 // New creates a new cache with the given options

137 > func New(maxSize int, opts *Options) StoppableCache { lru.go

138 > return NewWithMetrics(maxSize, opts, metrics.NoopMetricsHandler)

139 > }

140

141 // NewWithMetrics creates a new cache that will emit capacity and ttl metrics.

142 // handler should be tagged with metrics.CacheTypeTag.

143 > func NewWithMetrics(maxSize int, opts *Options, handler metrics.Handler) StoppableCache { lru.go

144 > if opts == nil {

145 opts = &Options{}

146 }

147

148 > backgroundEvict := opts.BackgroundEvict lru.go

149 > if backgroundEvict == nil {

150 > backgroundEvict = func() dynamicconfig.CacheBackgroundEvictSettings { lru.go

151 > return dynamicconfig.CacheBackgroundEvictSettings{

152 > Enabled: false,

153 > }

154 > }

155 }

156

157 > timeSource := opts.TimeSource lru.go

158 > if timeSource == nil {

159 > timeSource = clock.NewRealTimeSource() lru.go

160 > }

161

162 > metrics.CacheSize.With(handler).Record(float64(maxSize)) lru.go

163 > metrics.CacheTtl.With(handler).Record(opts.TTL)

164 > c := &lru{

165 > byAccess: list.New(),

166 > byKey: make(map[any]*list.Element),

167 > ttl: opts.TTL,

168 > maxSize: maxSize,

169 > currSize: 0,

170 > pin: opts.Pin,

171 > onPut: opts.OnPut,

172 > onEvict: opts.OnEvict,

173 > timeSource: timeSource,

174 > metricsHandler: handler,

175 > backgroundEvict: backgroundEvict,

176 > }

177 > if c.backgroundEvict().Enabled {

178 c.loops.Go(c.bgEvictLoop)

179 }

180 > return c lru.go

181 }

182

188

189 // Get retrieves the value stored under the given key

190 > func (c *lru) Get(key any) any { lru.go

191 > if c.maxSize == 0 { //

192 return nil

193 }

194 > c.mut.Lock() lru.go

195 > defer c.mut.Unlock()

196 >

197 > element := c.byKey[key]

198 > if element == nil {

199 > return nil lru.go

200 > }

201

202 entry := element.Value.(*entryImpl)

225

226 // PutIfNotExist puts a value associated with a given key if it does not exist

227 > func (c *lru) PutIfNotExist(key any, value any) (any, error) { lru.go

228 > existing, err := c.putInternal(key, value, false)

229 > if err != nil {

230 return nil, err

231 }

232

233 > if existing == nil { lru.go

234 > // This is a new value lru.go

235 > return value, err

236 > }

237

238 return existing, err

254

255 // Release decrements the ref count of a pinned element.

256 > func (c *lru) Release(key any) { lru.go

257 > if c.maxSize == 0 || !c.pin {

258 return

259 }

260 > c.mut.Lock() lru.go

261 > defer c.mut.Unlock()

262 >

263 > elt, ok := c.byKey[key]

264 > if !ok {

265 return

266 }

267 > entry := elt.Value.(*entryImpl) lru.go

268 > entry.refCount--

269 > if entry.refCount == 0 {

270 > c.pinnedSize -= entry.Size() lru.go

271 > metrics.CachePinnedUsage.With(c.metricsHandler).Record(float64(c.pinnedSize))

272 > }

273 // Entry size might have changed. Recalculate size and evict entries if necessary.

274 > newEntrySize := getSize(entry.value) lru.go

275 > c.currSize = c.calculateNewCacheSize(newEntrySize, entry.Size())

276 > entry.size = newEntrySize

277 > if c.currSize > c.maxSize {

278 c.tryEvictUntilCacheSizeUnderLimit()

279 }

280 > metrics.CacheUsage.With(c.metricsHandler).Record(float64(c.currSize)) lru.go

281 }

282

294 // Put puts a new value associated with a given key, returning the existing value (if present)

295 // allowUpdate flag is used to control overwrite behavior if the value exists.

296 > func (c *lru) putInternal(key any, value any, allowUpdate bool) (any, error) { lru.go

297 > if c.maxSize == 0 {

298 return nil, nil

299 }

300 > newEntrySize := getSize(value) lru.go

301 > if newEntrySize > c.maxSize {

302 return nil, ErrCacheItemTooLarge

303 }

304

305 > c.mut.Lock() lru.go

306 > defer c.mut.Unlock()

307 >

308 > elt := c.byKey[key]

309 > // If the entry exists, check if it has expired or update the value

310 > if elt != nil {

311 existingEntry := elt.Value.(*entryImpl)

312 if !c.isEntryExpired(existingEntry, c.timeSource.Now().UTC()) {

347 }

348

349 > c.tryEvictUntilEnoughSpaceWithSkipEntry(newEntrySize, nil) lru.go

350 >

351 > // check if the new entry can fit in the cache

352 > newCacheSize := c.calculateNewCacheSize(newEntrySize, emptyEntrySize)

353 > if newCacheSize > c.maxSize {

354 return nil, ErrCacheFull

355 }

356

357 > entry := &entryImpl{ lru.go

358 > key: key,

359 > value: value,

360 > size: newEntrySize,

361 > }

362 > c.updateEntryTTL(entry)

363 > c.updateEntryRefCount(entry)

364 > element := c.byAccess.PushFront(entry)

365 > c.byKey[key] = element

366 > c.currSize = newCacheSize

367 > metrics.CacheUsage.With(c.metricsHandler).Record(float64(c.currSize))

368 >

369 > if c.onPut != nil {

370 > c.onPut(value) lru.go

371 > }

372

373 > return nil, nil lru.go

374 }

375

376 > func (c *lru) calculateNewCacheSize(newEntrySize int, existingEntrySize int) int { lru.go

377 > return c.currSize - existingEntrySize + newEntrySize

378 > }

379

380 func (c *lru) deleteInternal(element *list.Element) {

397 // tryEvictUntilEnoughSpaceWithSkipEntry try to evict entries until there is enough space for the new entry without

398 // evicting the existing entry. the existing entry is skipped because it is being updated.

399 > func (c *lru) tryEvictUntilEnoughSpaceWithSkipEntry(newEntrySize int, existingEntry *entryImpl) { lru.go

400 > element := c.byAccess.Back()

401 > existingEntrySize := 0

402 > if existingEntry != nil {

403 existingEntrySize = existingEntry.Size()

404 }

405

406 > for c.calculateNewCacheSize(newEntrySize, existingEntrySize) > c.maxSize && element != nil { lru.go

407 entry := element.Value.(*entryImpl)

408 if existingEntry != nil && entry.key == existingEntry.key {

430 }

431

432 > func (c *lru) updateEntryTTL(entry *entryImpl) { lru.go

433 > if c.ttl != 0 {

434 > entry.createTime = c.timeSource.Now().UTC() lru.go

435 > }

436 }

437

438 > func (c *lru) updateEntryRefCount(entry *entryImpl) { lru.go

439 > if c.pin {

440 > entry.refCount++ lru.go

441 > if entry.refCount == 1 {

442 > c.pinnedSize += entry.Size()

443 > metrics.CachePinnedUsage.With(c.metricsHandler).Record(float64(c.pinnedSize))

444 > }

445 }

446 }

go.temporal.io/server/service/history/workflow/cache/cache.go 113 covered LOC · 26 ranges

Open complete file

95 logger log.Logger,

96 handler metrics.Handler,

97 > ) Cache { cache.go

98 > maxSize := config.HistoryHostLevelCacheMaxSize()

99 > if config.HistoryCacheLimitSizeBased {

100 maxSize = config.HistoryHostLevelCacheMaxSizeBytes()

101 }

102 > opts := &cache.Options{ cache.go

103 > TTL: config.HistoryCacheTTL(),

104 > Pin: true,

105 > BackgroundEvict: config.HistoryCacheBackgroundEvict,

106 > OnPut: func(val any) {

107 > //revive:disable-next-line:unchecked-type-assertion cache.go

108 > item := val.(*cacheItem)

109 > if item.finalizer == nil {

110 > return // should only happen in unit tests cache.go

111 > }

112 wfKey := item.wfContext.GetWorkflowKey()

113 err := item.finalizer.Register(wfKey.String(), func(ctx context.Context) error {

141 }

142

143 > taggedHandler := handler.WithTags(metrics.CacheTypeTag(metrics.MutableStateCacheTypeTagValue)) cache.go

144 > c := cache.NewWithMetrics(maxSize, opts, taggedHandler)

145 > return &cacheImpl{

146 > Cache: c,

147 > nonUserContextLockTimeout: config.HistoryCacheNonUserContextLockTimeout(),

148 > }

149 }

150

177 archetypeID chasm.ArchetypeID,

178 lockPriority locks.Priority,

179 > ) (historyi.ReleaseWorkflowContextFunc, error) { cache.go

180 > if err := c.validateWorkflowID(workflowID); err != nil {

181 return nil, err

182 }

183

184 > handler := shardContext.GetMetricsHandler().WithTags( cache.go

185 > metrics.OperationTag(metrics.HistoryCacheGetOrCreateCurrentScope),

186 > metrics.CacheTypeTag(metrics.MutableStateCacheTypeTagValue),

187 > metrics.NamespaceIDTag(namespaceID.String()),

188 > )

189 > metrics.CacheRequests.With(handler).Record(1)

190 > start := time.Now()

191 > defer func() { metrics.CacheLatency.With(handler).Record(time.Since(start)) }()

192

193 > execution := commonpb.WorkflowExecution{ cache.go

194 > WorkflowId: workflowID,

195 > // using empty run ID as current workflow run ID

196 > RunId: "",

197 > }

198 >

199 > _, weReleaseFn, err := c.getOrCreateWorkflowExecutionInternal(

200 > ctx,

201 > shardContext,

202 > namespaceID,

203 > &execution,

204 > archetypeID,

205 > handler,

206 > true,

207 > lockPriority,

208 > )

209 >

210 > metrics.ContextCounterAdd(ctx, metrics.HistoryWorkflowExecutionCacheLatency.Name(),

211 > time.Since(start).Nanoseconds())

212 >

213 > return weReleaseFn, err

214 }

215

262 forceClearContext bool,

263 lockPriority locks.Priority,

264 > ) (historyi.WorkflowContext, historyi.ReleaseWorkflowContextFunc, error) { cache.go

265 >

266 > if !softassert.That(

267 > shardContext.GetLogger(),

268 > archetypeID != chasm.UnspecifiedArchetypeID,

269 > "Creating execution cache key with unspecified archetype ID",

270 > ) {

271 archetypeID = chasm.WorkflowArchetypeID

272 }

273

274 > cacheKey := Key{ cache.go

275 > WorkflowKey: definition.NewWorkflowKey(namespaceID.String(), execution.GetWorkflowId(), execution.GetRunId()),

276 > ArchetypeID: archetypeID,

277 > ShardUUID: shardContext.GetOwner(),

278 > }

279 > item, cacheHit := c.Get(cacheKey).(*cacheItem)

280 > var workflowCtx historyi.WorkflowContext

281 > if cacheHit {

282 workflowCtx = item.wfContext

283 > } else { cache.go

284 > metrics.CacheMissCounter.With(handler).Record(1) cache.go

285 > workflowCtx = workflow.NewContext(

286 > shardContext.GetConfig(),

287 > cacheKey.WorkflowKey,

288 > archetypeID,

289 > shardContext.GetLogger(),

290 > shardContext.GetThrottledLogger(),

291 > shardContext.GetMetricsHandler(),

292 > )

293 >

294 > var err error

295 > value := &cacheItem{shardId: shardContext.GetShardID(), wfContext: workflowCtx, finalizer: shardContext.GetFinalizer()}

296 > existing, err := c.PutIfNotExist(cacheKey, value)

297 > if err != nil {

298 metrics.CacheFailures.With(handler).Record(1)

299 return nil, nil, err

300 }

301 //nolint:revive

302 > workflowCtx = existing.(*cacheItem).wfContext cache.go

303 }

304

305 > if err := c.lockWorkflowExecution(ctx, workflowCtx, cacheKey, lockPriority); err != nil { cache.go

306 metrics.CacheFailures.With(handler).Record(1)

307 metrics.AcquireLockFailedCounter.With(handler).Record(1)

311 // TODO This will create a closure on every request.

312 // Consider revisiting this if it causes too much GC activity

313 > releaseFunc := c.makeReleaseFunc(cacheKey, shardContext, workflowCtx, forceClearContext, handler, time.Now()) cache.go

314 >

315 > return workflowCtx, releaseFunc, nil

316 }

317

321 cacheKey Key,

322 lockPriority locks.Priority,

323 > ) error { cache.go

324 > // skip if there is no deadline

325 > if deadline, ok := ctx.Deadline(); ok {

326 var cancel context.CancelFunc

327 if headers.GetCallerInfo(ctx).CallerType != headers.CallerTypeAPI {

340 }

341

342 > if err := workflowCtx.Lock(ctx, lockPriority); err != nil { cache.go

343 // ctx is done before lock can be acquired

344 c.Release(cacheKey)

345 return consts.ErrResourceExhaustedBusyWorkflow

346 }

347 > return nil cache.go

348 }

349

355 handler metrics.Handler,

356 acquireTime time.Time,

357 > ) func(error) { cache.go

358 >

359 > status := cacheNotReleased

360 > return func(err error) {

361 > if atomic.CompareAndSwapInt32(&status, cacheNotReleased, cacheReleased) {

362 > defer func() {

363 > metrics.HistoryWorkflowExecutionCacheLockHoldDuration.With(handler).Record(time.Since(acquireTime))

364 > }()

365 > if rec := recover(); rec != nil {

366 wfContext.Clear()

367 wfContext.Unlock()

368 c.Release(cacheKey)

369 panic(rec)

370 > } else { cache.go

371 > if err != nil || forceClearContext {

372 > // TODO see issue #668, there are certain type or errors which can bypass the clear cache.go

373 > wfContext.Clear()

374 > wfContext.Unlock()

375 > c.Release(cacheKey)

376 > } else { cache.go

377 isDirty := wfContext.IsDirty()

378 if isDirty {

433 func (c *cacheImpl) validateWorkflowID(

434 workflowID string,

435 > ) error { cache.go

436 > if workflowID == "" {

437 return serviceerror.NewInvalidArgument("Can't load workflow execution. WorkflowId not set.")

438 }

439 > return nil cache.go

440 }

441

477 }

478

479 > func (c *cacheItem) CacheSize() int { cache.go

480 > if sg, ok := c.wfContext.(cache.SizeGetter); ok {

481 > return sg.CacheSize() cache.go

482 > }

483 return 0

484 }

go.temporal.io/server/common/metrics/tally_metrics_handler.go 107 covered LOC · 28 ranges

Open complete file

37 }

38

39 > func newSharedScopeCache(maxSize int) *sharedScopeCache { tally_metrics_handler.go

40 > return &sharedScopeCache{

41 > maxSize: maxSize,

42 > scopes: make(map[string]tally.Scope),

43 > handlers: make(map[string]*tallyMetricsHandler),

44 > }

45 > }

46

47 func (c *sharedScopeCache) loadOrStoreScope(key string, create func() tally.Scope) tally.Scope {

68 }

69

70 > func (c *sharedScopeCache) loadOrStoreHandler(key string, create func() *tallyMetricsHandler) *tallyMetricsHandler { tally_metrics_handler.go

71 > c.mu.RLock()

72 > if h, ok := c.handlers[key]; ok {

73 > c.mu.RUnlock() tally_metrics_handler.go

74 > return h

75 > }

76 > c.mu.RUnlock() tally_metrics_handler.go

77 >

78 > h := create()

79 >

80 > c.mu.Lock()

81 > defer c.mu.Unlock()

82 > // Double-check: another goroutine may have inserted while we were creating.

83 > if existing, ok := c.handlers[key]; ok {

84 return existing

85 }

86 > if len(c.handlers) >= c.maxSize { tally_metrics_handler.go

87 clear(c.handlers)

88 }

89 > c.handlers[key] = h tally_metrics_handler.go

90 > return h

91 }

92

109 var _ Handler = (*tallyMetricsHandler)(nil)

110

111 > func NewTallyMetricsHandler(cfg ClientConfig, scope tally.Scope) *tallyMetricsHandler { tally_metrics_handler.go

112 > perUnitBuckets := make(map[MetricUnit]tally.Buckets)

113 >

114 > for unit, boundariesList := range cfg.PerUnitHistogramBoundaries {

115 perUnitBuckets[MetricUnit(unit)] = tally.ValueBuckets(boundariesList)

116 }

117

118 > maxSize := cfg.TagsCacheMaxSize tally_metrics_handler.go

119 > if maxSize <= 0 {

120 > maxSize = defaultTagsCacheMaxSize tally_metrics_handler.go

121 > }

122

123 > return &tallyMetricsHandler{ tally_metrics_handler.go

124 > scope: scope,

125 > perUnitBuckets: perUnitBuckets,

126 > excludeTags: configExcludeTags(cfg),

127 > cache: newSharedScopeCache(maxSize),

128 > scopeKey: "",

129 > }

130 }

131

132 // tagsCacheKey builds a compact string key from a tag slice for use as a

133 // map lookup key.

134 > func tagsCacheKey(tags []Tag) string { tally_metrics_handler.go

135 > size := 0

136 > for i := range tags {

137 > size += len(tags[i].Key) + len(tags[i].Value) + 2*binary.MaxVarintLen64

138 > }

139 > var sb strings.Builder

140 > sb.Grow(size)

141 > for _, t := range tags {

142 > appendCacheKeyPart(&sb, t.Key)

143 > appendCacheKeyPart(&sb, t.Value)

144 > }

145 > return sb.String()

146 }

147

148 > func appendCacheKeyPart(sb *strings.Builder, value string) { tally_metrics_handler.go

149 > var lenBuf [binary.MaxVarintLen64]byte

150 > n := binary.PutUvarint(lenBuf[:], uint64(len(value)))

151 > _, _ = sb.Write(lenBuf[:n])

152 > sb.WriteString(value)

153 > }

154

155 // WithTags creates a new MetricProvider with provided []Tag

156 // Tags are merged with registered Tags from the source MetricsHandler.

157 // Handlers are cached by tag combination so repeated calls avoid allocations.

158 > func (tmh *tallyMetricsHandler) WithTags(tags ...Tag) Handler { tally_metrics_handler.go

159 > if len(tags) == 0 {

160 return tmh

161 }

162 > normalizedKey := tagsCacheKey(normalizeTagsForCaching(tags, tmh.excludeTags)) tally_metrics_handler.go

163 > key := tmh.scopeKey + normalizedKey

164 > return tmh.cache.loadOrStoreHandler(key, func() *tallyMetricsHandler {

165 > return &tallyMetricsHandler{

166 > scope: tmh.scope.Tagged(tagsToMap(tags, tmh.excludeTags)),

167 > perUnitBuckets: tmh.perUnitBuckets,

168 > excludeTags: tmh.excludeTags,

169 > cache: tmh.cache,

170 > scopeKey: key,

171 > }

172 > })

173 }

174

178 // excludeTags before cache key computation so that different raw values which

179 // map to the same excluded placeholder share a single cache entry.

180 > func (tmh *tallyMetricsHandler) cachedTaggedScope(tags []Tag) tally.Scope { tally_metrics_handler.go

181 > if len(tags) == 0 {

182 > return tmh.scope tally_metrics_handler.go

183 > }

184 key := tmh.scopeKey + tagsCacheKey(normalizeTagsForCaching(tags, tmh.excludeTags))

185 return tmh.cache.loadOrStoreScope(key, func() tally.Scope {

190 // normalizeTag applies excludeTags substitution to a single tag.

191 // Returns the (possibly modified) tag and whether it was normalized.

192 > func normalizeTag(t Tag, excl excludeTags) (Tag, bool) { tally_metrics_handler.go

193 > if vals, ok := excl[t.Key]; ok {

194 if _, ok := vals[t.Value]; !ok {

195 return Tag{Key: t.Key, Value: tagExcludedValue}, true

196 }

197 }

198 > return t, false tally_metrics_handler.go

199 }

200

202 // canonical tag values for cache key computation. Returns the original slice

203 // unchanged if no tags need normalization (zero-alloc fast path).

204 > func normalizeTagsForCaching(tags []Tag, excl excludeTags) []Tag { tally_metrics_handler.go

205 > if len(excl) == 0 {

206 > return tags tally_metrics_handler.go

207 > }

208 var normalized []Tag

209 for i, t := range tags {

223

224 // Counter obtains a counter for the given name.

225 > func (tmh *tallyMetricsHandler) Counter(counter string) CounterIface { tally_metrics_handler.go

226 > if v, ok := tmh.counters.Load(counter); ok {

227 > return v.(CounterIface) //nolint:revive // type-safe: only CounterIface is stored tally_metrics_handler.go

228 > }

229 > c := CounterFunc(func(i int64, t ...Tag) { tally_metrics_handler.go

230 > tmh.cachedTaggedScope(t).Counter(counter).Inc(i)

231 > })

232 > actual, _ := tmh.counters.LoadOrStore(counter, c)

233 > return actual.(CounterIface) //nolint:revive // type-safe: only CounterIface is stored

234 }

235

247

248 // Timer obtains a timer for the given name.

249 > func (tmh *tallyMetricsHandler) Timer(timer string) TimerIface { tally_metrics_handler.go

250 > if v, ok := tmh.timers.Load(timer); ok {

251 > return v.(TimerIface) //nolint:revive // type-safe: only TimerIface is stored tally_metrics_handler.go

252 > }

253 > ti := TimerFunc(func(d time.Duration, t ...Tag) { tally_metrics_handler.go

254 > tmh.cachedTaggedScope(t).Timer(timer).Record(d)

255 > })

256 > actual, _ := tmh.timers.LoadOrStore(timer, ti)

257 > return actual.(TimerIface) //nolint:revive // type-safe: only TimerIface is stored

258 }

259

281 }

282

283 > func tagsToMap(t1 []Tag, e excludeTags) map[string]string { tally_metrics_handler.go

284 > if len(t1) == 0 {

285 return nil

286 }

287

288 > m := make(map[string]string, len(t1)) tally_metrics_handler.go

289 > for i := range t1 {

290 > nt, _ := normalizeTag(t1[i], e)

291 > m[nt.Key] = nt.Value

292 > }

293 > return m

294 }

go.temporal.io/server/api/persistence/v1/chasm.pb.go 102 covered LOC · 28 ranges

Open complete file

50 func (*ChasmNode) ProtoMessage() {}

51

52 > func (x *ChasmNode) ProtoReflect() protoreflect.Message { chasm.pb.go

53 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[0]

54 > if x != nil {

55 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) chasm.pb.go

56 > if ms.LoadMessageInfo() == nil {

57 > ms.StoreMessageInfo(mi)

58 > }

59 > return ms

60 }

61 return mi.MessageOf(x)

67 }

68

69 > func (x *ChasmNode) GetMetadata() *ChasmNodeMetadata { chasm.pb.go

70 > if x != nil {

71 > return x.Metadata

72 > }

73 return nil

74 }

111 func (*ChasmNodeMetadata) ProtoMessage() {}

112

113 > func (x *ChasmNodeMetadata) ProtoReflect() protoreflect.Message { chasm.pb.go

114 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[1]

115 > if x != nil {

116 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

117 if ms.LoadMessageInfo() == nil {

120 return ms

121 }

122 > return mi.MessageOf(x) chasm.pb.go

123 }

124

135 }

136

137 > func (x *ChasmNodeMetadata) GetLastUpdateVersionedTransition() *VersionedTransition { chasm.pb.go

138 > if x != nil {

139 > return x.LastUpdateVersionedTransition

140 > }

141 return nil

142 }

143

144 > func (x *ChasmNodeMetadata) GetAttributes() isChasmNodeMetadata_Attributes { chasm.pb.go

145 > if x != nil {

146 > return x.Attributes

147 > }

148 return nil

149 }

150

151 > func (x *ChasmNodeMetadata) GetComponentAttributes() *ChasmComponentAttributes { chasm.pb.go

152 > if x != nil {

153 > if x, ok := x.Attributes.(*ChasmNodeMetadata_ComponentAttributes); ok { chasm.pb.go

154 > return x.ComponentAttributes chasm.pb.go

155 > }

156 }

157 return nil

250 func (*ChasmComponentAttributes) ProtoMessage() {}

251

252 > func (x *ChasmComponentAttributes) ProtoReflect() protoreflect.Message { chasm.pb.go

253 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[2]

254 > if x != nil {

255 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

256 if ms.LoadMessageInfo() == nil {

259 return ms

260 }

261 > return mi.MessageOf(x) chasm.pb.go

262 }

263

267 }

268

269 > func (x *ChasmComponentAttributes) GetTypeId() uint32 { chasm.pb.go

270 > if x != nil {

271 > return x.TypeId

272 > }

273 return 0

274 }

275

276 > func (x *ChasmComponentAttributes) GetSideEffectTasks() []*ChasmComponentAttributes_Task { chasm.pb.go

277 > if x != nil {

278 > return x.SideEffectTasks

279 > }

280 return nil

281 }

282

283 > func (x *ChasmComponentAttributes) GetPureTasks() []*ChasmComponentAttributes_Task { chasm.pb.go

284 > if x != nil {

285 > return x.PureTasks

286 > }

287 return nil

288 }

429 func (*ChasmDataAttributes) ProtoMessage() {}

430

431 > func (x *ChasmDataAttributes) ProtoReflect() protoreflect.Message { chasm.pb.go

432 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[5]

433 > if x != nil {

434 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

435 if ms.LoadMessageInfo() == nil {

438 return ms

439 }

440 > return mi.MessageOf(x) chasm.pb.go

441 }

442

465 func (*ChasmCollectionAttributes) ProtoMessage() {}

466

467 > func (x *ChasmCollectionAttributes) ProtoReflect() protoreflect.Message { chasm.pb.go

468 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[6]

469 > if x != nil {

470 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

471 if ms.LoadMessageInfo() == nil {

474 return ms

475 }

476 > return mi.MessageOf(x) chasm.pb.go

477 }

478

502 func (*ChasmPointerAttributes) ProtoMessage() {}

503

504 > func (x *ChasmPointerAttributes) ProtoReflect() protoreflect.Message { chasm.pb.go

505 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[7]

506 > if x != nil {

507 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

508 if ms.LoadMessageInfo() == nil {

511 return ms

512 }

513 > return mi.MessageOf(x) chasm.pb.go

514 }

515

571 func (*ChasmTaskInfo) ProtoMessage() {}

572

573 > func (x *ChasmTaskInfo) ProtoReflect() protoreflect.Message { chasm.pb.go

574 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[8]

575 > if x != nil {

576 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

577 if ms.LoadMessageInfo() == nil {

580 return ms

581 }

582 > return mi.MessageOf(x) chasm.pb.go

583 }

584

908 func (*ChasmComponentAttributes_Task) ProtoMessage() {}

909

910 > func (x *ChasmComponentAttributes_Task) ProtoReflect() protoreflect.Message { chasm.pb.go

911 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[11]

912 > if x != nil {

913 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

914 if ms.LoadMessageInfo() == nil {

917 return ms

918 }

919 > return mi.MessageOf(x) chasm.pb.go

920 }

921

999 func (*ChasmComponentAttributes_RequestMetadata) ProtoMessage() {}

1000

1001 > func (x *ChasmComponentAttributes_RequestMetadata) ProtoReflect() protoreflect.Message { chasm.pb.go

1002 > mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[12]

1003 > if x != nil {

1004 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1005 if ms.LoadMessageInfo() == nil {

1008 return ms

1009 }

1010 > return mi.MessageOf(x) chasm.pb.go

1011 }

1012

1180 }

1181

1182 > func init() { file_temporal_server_api_persistence_v1_chasm_proto_init() } chasm.pb.go

1183 > func file_temporal_server_api_persistence_v1_chasm_proto_init() {

1184 > if File_temporal_server_api_persistence_v1_chasm_proto != nil {

1185 > return

1186 > }

1187 > file_temporal_server_api_persistence_v1_hsm_proto_init()

1188 > file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[1].OneofWrappers = []any{

1189 > (*ChasmNodeMetadata_ComponentAttributes)(nil),

1190 > (*ChasmNodeMetadata_DataAttributes)(nil),

1191 > (*ChasmNodeMetadata_CollectionAttributes)(nil),

1192 > (*ChasmNodeMetadata_PointerAttributes)(nil),

1193 > }

1194 > file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[10].OneofWrappers = []any{

1195 > (*ChasmNexusCompletion_Success)(nil),

1196 > (*ChasmNexusCompletion_Failure)(nil),

1197 > }

1198 > type x struct{}

1199 > out := protoimpl.TypeBuilder{

1200 > File: protoimpl.DescBuilder{

1201 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

1202 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_chasm_proto_rawDesc), len(file_temporal_server_api_persistence_v1_chasm_proto_rawDesc)),

1203 > NumEnums: 0,

1204 > NumMessages: 15,

1205 > NumExtensions: 0,

1206 > NumServices: 0,

1207 > },

1208 > GoTypes: file_temporal_server_api_persistence_v1_chasm_proto_goTypes,

1209 > DependencyIndexes: file_temporal_server_api_persistence_v1_chasm_proto_depIdxs,

1210 > MessageInfos: file_temporal_server_api_persistence_v1_chasm_proto_msgTypes,

1211 > }.Build()

1212 > File_temporal_server_api_persistence_v1_chasm_proto = out.File

1213 > file_temporal_server_api_persistence_v1_chasm_proto_goTypes = nil

1214 > file_temporal_server_api_persistence_v1_chasm_proto_depIdxs = nil

1215 }

go.temporal.io/server/service/history/shard/context_testutil.go 102 covered LOC · 8 ranges

Open complete file

56 shardInfo *persistencespb.ShardInfo,

57 config *configs.Config,

58 > ) *ContextTest { context_testutil.go

59 > resourceTest := resourcetest.NewTest(ctrl, primitives.HistoryService)

60 > eventsCache := events.NewMockCache(ctrl)

61 > shard := newTestContext(

62 > resourceTest,

63 > eventsCache,

64 > ContextConfigOverrides{

65 > ShardInfo: shardInfo,

66 > Config: config,

67 > },

68 > )

69 > return &ContextTest{

70 > Resource: resourceTest,

71 > ContextImpl: shard,

72 > MockEventsCache: eventsCache,

73 > }

74 > }

75

76 type ContextConfigOverrides struct {

107 }

108

109 > func newTestContext(t *resourcetest.Test, eventsCache events.Cache, config ContextConfigOverrides) *ContextImpl { context_testutil.go

110 > hostInfoProvider := t.GetHostInfoProvider()

111 > lifecycleCtx, lifecycleCancel := context.WithCancel(context.Background())

112 > if config.ShardInfo.QueueStates == nil {

113 > config.ShardInfo.QueueStates = make(map[int32]*persistencespb.QueueState) context_testutil.go

114 > }

115 > registry := config.Registry context_testutil.go

116 > if registry == nil {

117 > registry = t.GetNamespaceRegistry()

118 > }

119 > clusterMetadata := config.ClusterMetadata

120 > if clusterMetadata == nil {

121 > clusterMetadata = t.GetClusterMetadata()

122 > }

123 > executionManager := config.ExecutionManager

124 > if executionManager == nil {

125 > executionManager = t.ExecutionMgr

126 > }

127 > taskCategoryRegistry := tasks.NewDefaultTaskCategoryRegistry()

128 > taskCategoryRegistry.AddCategory(tasks.CategoryArchival)

129 >

130 > ctx := &ContextImpl{

131 > shardID: config.ShardInfo.GetShardId(),

132 > owner: config.ShardInfo.GetOwner(),

133 > stringRepr: fmt.Sprintf("Shard(%d)", config.ShardInfo.GetShardId()),

134 > executionManager: executionManager,

135 > metricsHandler: t.MetricsHandler,

136 > eventsCache: eventsCache,

137 > config: config.Config,

138 > contextTaggedLogger: t.GetLogger(),

139 > throttledLogger: t.GetThrottledLogger(),

140 > lifecycleCtx: lifecycleCtx,

141 > lifecycleCancel: lifecycleCancel,

142 > queueMetricEmitter: sync.Once{},

143 >

144 > state: contextStateAcquired,

145 > engineFuture: future.NewFuture[historyi.Engine](),

146 > shardInfo: config.ShardInfo,

147 > remoteClusterInfos: make(map[string]*remoteClusterInfo),

148 >

149 > clusterMetadata: clusterMetadata,

150 > timeSource: t.TimeSource,

151 > namespaceRegistry: registry,

152 > stateMachineRegistry: hsm.NewRegistry(),

153 > chasmRegistry: chasm.NewRegistry(t.GetLogger()),

154 > businessIDRateLimiters: cache.New(

155 > config.Config.BusinessIDReuseLimiterCacheSize(),

156 > &cache.Options{TTL: config.Config.BusinessIDReuseLimiterCacheTTL()},

157 > ),

158 > persistenceShardManager: t.GetShardManager(),

159 > clientBean: t.GetClientBean(),

160 > saProvider: t.GetSearchAttributesProvider(),

161 > saMapperProvider: t.GetSearchAttributesMapperProvider(),

162 > historyClient: t.GetHistoryClient(),

163 > payloadSerializer: t.GetPayloadSerializer(),

164 > archivalMetadata: t.GetArchivalMetadata(),

165 > hostInfoProvider: hostInfoProvider,

166 > taskCategoryRegistry: taskCategoryRegistry,

167 > ioSemaphore: locks.NewPrioritySemaphore(1),

168 > }

169 > ctx.taskKeyManager = newTaskKeyManager(

170 > ctx.taskCategoryRegistry,

171 > ctx.timeSource,

172 > config.Config,

173 > ctx.GetLogger(),

174 > func() error {

175 return ctx.renewRangeLocked(false)

176 },

177 )

178 > ctx.taskKeyManager.setRangeID(config.ShardInfo.RangeId) context_testutil.go

179 > ctx.handoverTracker = NewDefaultHandoverTrackerFactory()(HandoverTrackerParams{

180 > ClusterMetadata: clusterMetadata,

181 > GetMaxReplicationTaskID: ctx.getMaxReplicationTaskID,

182 > ErrorByStateFn: ctx.errorByState,

183 > NotifyReplicationFn: ctx.notifyReplicationQueueProcessor,

184 > NamespaceRegistry: registry,

185 > Logger: ctx.contextTaggedLogger,

186 > })

187 > return ctx

188 }

189

190 // SetEngineForTest sets s.engine. Only used by tests.

191 > func (s *ContextTest) SetEngineForTesting(engine historyi.Engine) { context_testutil.go

192 > s.engineFuture.Set(engine, nil)

193 > }

194

195 // SetEventsCacheForTesting sets s.eventsCache. Only used by tests.

216

217 // SetStateMachineRegistry sets the state machine registry on this shard.

218 > func (s *ContextTest) SetStateMachineRegistry(reg *hsm.Registry) { context_testutil.go

219 > s.stateMachineRegistry = reg

220 > }

221

222 > func (s *ContextTest) SetChasmRegistry(reg *chasm.Registry) { context_testutil.go

223 > s.chasmRegistry = reg

224 > }

225

226 func (s *ContextTest) SetChasmWorkflowRegistry(reg *chasmworkflow.Registry) {

go.temporal.io/server/api/persistence/v1/predicates.pb.go 82 covered LOC · 22 ranges

Open complete file

57 func (*Predicate) ProtoMessage() {}

58

59 > func (x *Predicate) ProtoReflect() protoreflect.Message { predicates.pb.go

60 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[0]

61 > if x != nil {

62 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

63 > if ms.LoadMessageInfo() == nil {

64 > ms.StoreMessageInfo(mi)

65 > }

66 > return ms

67 }

68 return mi.MessageOf(x)

261 func (*UniversalPredicateAttributes) ProtoMessage() {}

262

263 > func (x *UniversalPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

264 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[1]

265 > if x != nil {

266 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

267 if ms.LoadMessageInfo() == nil {

270 return ms

271 }

272 > return mi.MessageOf(x) predicates.pb.go

273 }

274

297 func (*EmptyPredicateAttributes) ProtoMessage() {}

298

299 > func (x *EmptyPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

300 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[2]

301 > if x != nil {

302 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

303 if ms.LoadMessageInfo() == nil {

306 return ms

307 }

308 > return mi.MessageOf(x) predicates.pb.go

309 }

310

334 func (*AndPredicateAttributes) ProtoMessage() {}

335

336 > func (x *AndPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

337 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[3]

338 > if x != nil {

339 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

340 if ms.LoadMessageInfo() == nil {

343 return ms

344 }

345 > return mi.MessageOf(x) predicates.pb.go

346 }

347

378 func (*OrPredicateAttributes) ProtoMessage() {}

379

380 > func (x *OrPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

381 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[4]

382 > if x != nil {

383 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

384 if ms.LoadMessageInfo() == nil {

387 return ms

388 }

389 > return mi.MessageOf(x) predicates.pb.go

390 }

391

422 func (*NotPredicateAttributes) ProtoMessage() {}

423

424 > func (x *NotPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

425 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[5]

426 > if x != nil {

427 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

428 if ms.LoadMessageInfo() == nil {

431 return ms

432 }

433 > return mi.MessageOf(x) predicates.pb.go

434 }

435

466 func (*NamespaceIdPredicateAttributes) ProtoMessage() {}

467

468 > func (x *NamespaceIdPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

469 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[6]

470 > if x != nil {

471 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

472 if ms.LoadMessageInfo() == nil {

475 return ms

476 }

477 > return mi.MessageOf(x) predicates.pb.go

478 }

479

510 func (*TaskTypePredicateAttributes) ProtoMessage() {}

511

512 > func (x *TaskTypePredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

513 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[7]

514 > if x != nil {

515 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

516 if ms.LoadMessageInfo() == nil {

519 return ms

520 }

521 > return mi.MessageOf(x) predicates.pb.go

522 }

523

554 func (*DestinationPredicateAttributes) ProtoMessage() {}

555

556 > func (x *DestinationPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

557 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[8]

558 > if x != nil {

559 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

560 if ms.LoadMessageInfo() == nil {

563 return ms

564 }

565 > return mi.MessageOf(x) predicates.pb.go

566 }

567

598 func (*OutboundTaskGroupPredicateAttributes) ProtoMessage() {}

599

600 > func (x *OutboundTaskGroupPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

601 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[9]

602 > if x != nil {

603 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

604 if ms.LoadMessageInfo() == nil {

607 return ms

608 }

609 > return mi.MessageOf(x) predicates.pb.go

610 }

611

642 func (*OutboundTaskPredicateAttributes) ProtoMessage() {}

643

644 > func (x *OutboundTaskPredicateAttributes) ProtoReflect() protoreflect.Message { predicates.pb.go

645 > mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[10]

646 > if x != nil {

647 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

648 if ms.LoadMessageInfo() == nil {

651 return ms

652 }

653 > return mi.MessageOf(x) predicates.pb.go

654 }

655

828 }

829

830 > func init() { file_temporal_server_api_persistence_v1_predicates_proto_init() } predicates.pb.go

831 > func file_temporal_server_api_persistence_v1_predicates_proto_init() {

832 > if File_temporal_server_api_persistence_v1_predicates_proto != nil {

833 > return

834 > }

835 > file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[0].OneofWrappers = []any{

836 > (*Predicate_UniversalPredicateAttributes)(nil),

837 > (*Predicate_EmptyPredicateAttributes)(nil),

838 > (*Predicate_AndPredicateAttributes)(nil),

839 > (*Predicate_OrPredicateAttributes)(nil),

840 > (*Predicate_NotPredicateAttributes)(nil),

841 > (*Predicate_NamespaceIdPredicateAttributes)(nil),

842 > (*Predicate_TaskTypePredicateAttributes)(nil),

843 > (*Predicate_DestinationPredicateAttributes)(nil),

844 > (*Predicate_OutboundTaskGroupPredicateAttributes)(nil),

845 > (*Predicate_OutboundTaskPredicateAttributes)(nil),

846 > }

847 > type x struct{}

848 > out := protoimpl.TypeBuilder{

849 > File: protoimpl.DescBuilder{

850 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

851 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_predicates_proto_rawDesc), len(file_temporal_server_api_persistence_v1_predicates_proto_rawDesc)),

852 > NumEnums: 0,

853 > NumMessages: 12,

854 > NumExtensions: 0,

855 > NumServices: 0,

856 > },

857 > GoTypes: file_temporal_server_api_persistence_v1_predicates_proto_goTypes,

858 > DependencyIndexes: file_temporal_server_api_persistence_v1_predicates_proto_depIdxs,

859 > MessageInfos: file_temporal_server_api_persistence_v1_predicates_proto_msgTypes,

860 > }.Build()

861 > File_temporal_server_api_persistence_v1_predicates_proto = out.File

862 > file_temporal_server_api_persistence_v1_predicates_proto_goTypes = nil

863 > file_temporal_server_api_persistence_v1_predicates_proto_depIdxs = nil

864 }

go.temporal.io/server/common/log/zap_logger.go 80 covered LOC · 21 ranges

Open complete file

58 // NewTestLogger returns a logger for tests

59 // Deprecated: Use testlogger.TestLogger instead.

60 > func NewTestLogger() *zapLogger { zap_logger.go

61 > format := os.Getenv(TestLogFormatEnvVar)

62 > if format == "" {

63 > format = "console"

64 > }

65

66 > logger := BuildZapLogger(Config{ zap_logger.go

67 > Level: os.Getenv(TestLogLevelEnvVar),

68 > Format: format,

69 > Development: true,

70 > })

71 >

72 > // Don't include stack traces for warnings during tests. Only include them for logs with level error and above.

73 > logger = logger.WithOptions(zap.AddStacktrace(zap.ErrorLevel))

74 >

75 > return NewZapLogger(logger)

76 }

77

82

83 // NewZapLogger returns a new zap based logger from zap.Logger

84 > func NewZapLogger(zl *zap.Logger) *zapLogger { zap_logger.go

85 > return &zapLogger{

86 > zl: zl,

87 > skip: skipForZapLogger,

88 > baseZl: zl,

89 > }

90 > }

91

92 // BuildZapLogger builds and returns a new zap.Logger for this logging configuration

93 > func BuildZapLogger(cfg Config) *zap.Logger { zap_logger.go

94 > return buildZapLogger(cfg, true)

95 > }

96

97 > func caller(skip int) string { zap_logger.go

98 > _, path, line, ok := runtime.Caller(skip)

99 > if !ok {

100 return ""

101 }

102 > return path + ":" + strconv.Itoa(line) zap_logger.go

103 }

104

105 > func (l *zapLogger) buildFieldsWithCallAt(tags []tag.Tag) []zap.Field { zap_logger.go

106 > fields := make([]zap.Field, len(tags)+1)

107 > l.fillFields(tags, fields)

108 > fields[len(fields)-1] = zap.String(tag.LoggingCallAtKey, caller(l.skip))

109 > return fields

110 > }

111

112 // fillFields fill fields parameter with fields read from tags. Optimized for performance.

113 > func (l *zapLogger) fillFields(tags []tag.Tag, fields []zap.Field) { zap_logger.go

114 > for i, t := range tags {

115 > if zt, ok := t.(tag.ZapTag); ok { zap_logger.go

116 > fields[i] = zt.Field()

117 > } else {

118 fields[i] = zap.Any(t.Key(), t.Value())

119 }

121 }

122

123 > func setDefaultMsg(msg string) string { zap_logger.go

124 > if msg == "" {

125 return defaultMsgForEmpty

126 }

127 > return msg zap_logger.go

128 }

129

130 > func (l *zapLogger) Debug(msg string, tags ...tag.Tag) { zap_logger.go

131 > if l.zl.Core().Enabled(zap.DebugLevel) {

132 msg = setDefaultMsg(msg)

133 fields := l.buildFieldsWithCallAt(tags)

136 }

137

138 > func (l *zapLogger) Info(msg string, tags ...tag.Tag) { zap_logger.go

139 > if l.zl.Core().Enabled(zap.InfoLevel) {

140 > msg = setDefaultMsg(msg)

141 > fields := l.buildFieldsWithCallAt(tags)

142 > l.zl.Info(msg, fields...)

143 > }

144 }

145

234 }

235

236 > func buildZapLogger(cfg Config, disableCaller bool) *zap.Logger { zap_logger.go

237 > encodeConfig := DefaultZapEncoderConfig

238 > if disableCaller {

239 > encodeConfig.CallerKey = zapcore.OmitKey

240 > encodeConfig.EncodeCaller = nil

241 > }

242

243 > outputPath := "stderr" zap_logger.go

244 > if len(cfg.OutputFile) > 0 {

245 outputPath = cfg.OutputFile

246 }

247 > if cfg.Stdout { zap_logger.go

248 outputPath = "stdout"

249 }

250 > encoding := "json" zap_logger.go

251 > if cfg.Format == "console" {

252 > encoding = "console" zap_logger.go

253 > }

254 > config := zap.Config{ zap_logger.go

255 > Level: zap.NewAtomicLevelAt(ParseZapLevel(cfg.Level)),

256 > Development: cfg.Development,

257 > Sampling: nil,

258 > Encoding: encoding,

259 > EncoderConfig: encodeConfig,

260 > OutputPaths: []string{outputPath},

261 > ErrorOutputPaths: []string{outputPath},

262 > DisableCaller: disableCaller,

263 > }

264 > logger, _ := config.Build()

265 > return logger

266 }

267

297 }

298

299 > func ParseZapLevel(level string) zapcore.Level { zap_logger.go

300 > switch strings.ToLower(level) {

301 case "debug":

302 return zap.DebugLevel

313 case "fatal":

314 return zap.FatalLevel

315 > default: zap_logger.go

316 > return zap.InfoLevel

317 }

318 }

go.temporal.io/server/service/history/historybuilder/event_store.go 74 covered LOC · 21 ranges

Open complete file

49 }

50

51 > func (b *EventStore) IsDirty() bool { event_store.go

52 > return len(b.memEventsBatches) > 0 ||

53 > len(b.memLatestBatch) > 0 ||

54 > len(b.memBufferBatch) > 0 ||

55 > len(b.scheduledIDToStartedID) > 0

56 > }

57

58 func (b *EventStore) AllocateEventID() int64 {

62 }

63

64 > func (b *EventStore) NextEventID() int64 { event_store.go

65 > return b.nextEventID

66 > }

67

68 func (b *EventStore) LastEventVersion() (int64, bool) {

144 }

145

146 > func (b *EventStore) NumBufferedEvents() int { event_store.go

147 > return len(b.dbBufferBatch) + len(b.memBufferBatch)

148 > }

149

150 > func (b *EventStore) SizeInBytesOfBufferedEvents() int { event_store.go

151 > size := 0

152 > for _, ev := range b.dbBufferBatch {

153 size += proto.Size(ev)

154 }

155 > for _, ev := range b.memBufferBatch { event_store.go

156 size += proto.Size(ev)

157 }

158 > return size event_store.go

159 }

160

161 > func (b *EventStore) FlushBufferToCurrentBatch() (map[int64]int64, map[string]int64) { event_store.go

162 > if len(b.dbBufferBatch) == 0 && len(b.memBufferBatch) == 0 {

163 > return b.scheduledIDToStartedID, b.requestIDToEventID event_store.go

164 > }

165

166 b.assertMutable()

200 }

201

202 > func (b *EventStore) FlushAndCreateNewBatch() { event_store.go

203 > b.assertNotSealed()

204 > if len(b.memLatestBatch) == 0 {

205 > return event_store.go

206 > }

207

208 b.memEventsBatches = append(b.memEventsBatches, b.memLatestBatch)

213 func (b *EventStore) Finish(

214 flushBufferEvent bool,

215 > ) (*HistoryMutation, error) { event_store.go

216 > defer func() {

217 > b.state = HistoryBuilderStateSealed

218 > }()

219

220 > if flushBufferEvent { event_store.go

221 > _, _ = b.FlushBufferToCurrentBatch() event_store.go

222 > }

223 > b.FlushAndCreateNewBatch() event_store.go

224 >

225 > dbEventsBatches := b.memEventsBatches

226 > dbClearBuffer := b.dbClearBuffer

227 > dbBufferBatch := b.memBufferBatch

228 > memBufferBatch := b.dbBufferBatch

229 > memBufferBatch = append(memBufferBatch, dbBufferBatch...)

230 > scheduledIDToStartedID := b.scheduledIDToStartedID

231 > requestIDToEventID := b.requestIDToEventID

232 >

233 > b.memEventsBatches = nil

234 > b.memBufferBatch = nil

235 > b.memLatestBatch = nil

236 > b.memLatestBatchSize = 0

237 > b.dbClearBuffer = false

238 > b.dbBufferBatch = nil

239 > b.scheduledIDToStartedID = nil

240 >

241 > if err := b.assignTaskIDs(dbEventsBatches); err != nil {

242 return nil, err

243 }

244

245 > return &HistoryMutation{ event_store.go

246 > DBEventsBatches: dbEventsBatches,

247 > DBClearBuffer: dbClearBuffer,

248 > DBBufferBatch: dbBufferBatch,

249 > MemBufferBatch: memBufferBatch,

250 > ScheduledIDToStartedID: scheduledIDToStartedID,

251 > RequestIDToEventID: requestIDToEventID,

252 > }, nil

253 }

254

255 func (b *EventStore) assignTaskIDs(

256 dbEventsBatches [][]*historypb.HistoryEvent,

257 > ) error { event_store.go

258 > b.assertNotSealed()

259 >

260 > if b.state == HistoryBuilderStateImmutable {

261 return nil

262 }

263

264 > taskIDCount := 0 event_store.go

265 > for i := range dbEventsBatches {

266 taskIDCount += len(dbEventsBatches[i])

267 }

268 > taskIDs, err := b.taskIDGenerator(taskIDCount) event_store.go

269 > if err != nil {

270 return err

271 }

272

273 > taskIDPointer := 0 event_store.go

274 > height := len(dbEventsBatches)

275 > for i := range height {

276 width := len(dbEventsBatches[i])

277 for j := range width {

280 }

281 }

282 > return nil event_store.go

283 }

284

289 }

290

291 > func (b *EventStore) assertNotSealed() { event_store.go

292 > if b.state == HistoryBuilderStateSealed {

293 panic("history builder is in sealed state")

294 }

go.temporal.io/server/service/history/workflow/context.go 72 covered LOC · 16 ranges

Open complete file

88 throttledLogger log.ThrottledLogger,

89 metricsHandler metrics.Handler,

90 > ) *ContextImpl { context.go

91 > tags := func() []tag.Tag {

92 return []tag.Tag{

93 tag.WorkflowNamespaceID(workflowKey.NamespaceID),

96 }

97 }

98 > contextImpl := &ContextImpl{ context.go

99 > workflowKey: workflowKey,

100 > archetypeID: archetypeID,

101 > logger: log.NewLazyLogger(logger, tags),

102 > throttledLogger: log.NewLazyLogger(throttledLogger, tags),

103 > metricsHandler: metricsHandler.WithTags(metrics.OperationTag(metrics.WorkflowContextScope)),

104 > config: config,

105 > lock: locks.NewPrioritySemaphore(1),

106 > }

107 > softassert.That(

108 > contextImpl.throttledLogger,

109 > contextImpl.archetypeID != chasm.UnspecifiedArchetypeID,

110 > "Creating execution context with unspecified archetype ID",

111 > )

112 >

113 > return contextImpl

114 }

115

117 ctx context.Context,

118 lockPriority locks.Priority,

119 > ) error { context.go

120 > return c.lock.Acquire(ctx, lockPriority, 1)

121 > }

122

123 > func (c *ContextImpl) Unlock() { context.go

124 > c.lock.Release(1)

125 > }

126

127 func (c *ContextImpl) IsDirty() bool {

132 }

133

134 > func (c *ContextImpl) Clear() { context.go

135 > metrics.WorkflowContextCleared.With(c.metricsHandler).Record(1)

136 > if c.MutableState != nil {

137 c.MutableState.GetQueryRegistry().Clear()

138 c.MutableState.RemoveSpeculativeWorkflowTaskTimeoutTask()

139 c.MutableState = nil

140 }

141 > if c.updateRegistry != nil { context.go

142 c.updateRegistry.Clear()

143 c.updateRegistry = nil

144 }

145 > c.clearTaskCompletionBuffer() context.go

146 }

147

148 // clearTaskCompletionBuffer drops the in-progress buffer

149 > func (c *ContextImpl) clearTaskCompletionBuffer() { context.go

150 > if c.taskCompletionBuffer == nil {

151 > return context.go

152 > }

153 c.taskCompletionBuffer = nil

154 }

451 newWorkflowEvents []*persistence.WorkflowEvents,

452 transactionPolicy historyi.TransactionPolicy,

453 > ) (retError error) { context.go

454 >

455 > if transactionPolicy == historyi.TransactionPolicyActive {

456 > if rl := shardContext.BusinessIDReuseRateLimiter(

457 > namespace.ID(c.workflowKey.NamespaceID),

458 > c.workflowKey.WorkflowID,

459 > c.archetypeID,

460 > ); rl != nil && !rl.Allow() {

461 archetypeName, _ := shardContext.ChasmRegistry().ArchetypeDisplayName(c.archetypeID)

462 metrics.BusinessIDReuseRateLimited.With(shardContext.GetMetricsHandler()).Record(

470 }

471

472 > defer func() { context.go

473 > if retError != nil {

474 > c.Clear() context.go

475 > }

476 }()

477

478 > createRequest := &persistence.CreateWorkflowExecutionRequest{ context.go

479 > ShardID: shardContext.GetShardID(),

480 > // workflow create mode & prev run ID & version

481 > Mode: createMode,

482 > PreviousRunID: prevRunID,

483 > PreviousLastWriteVersion: prevLastWriteVersion,

484 >

485 > ArchetypeID: c.archetypeID,

486 >

487 > NewWorkflowSnapshot: *newWorkflow,

488 > NewWorkflowEvents: newWorkflowEvents,

489 > }

490 >

491 > _, err := createWorkflowExecution(

492 > ctx,

493 > shardContext,

494 > newMutableState.GetCurrentVersion(),

495 > createRequest,

496 > newMutableState.IsWorkflow(),

497 > )

498 > if err != nil {

499 > return err context.go

500 > }

501

502 engine, err := shardContext.GetEngine(ctx)

1418 // CacheSize estimates the in-memory size of the object for cache limits. For proto objects, it uses proto.Size()

1419 // which returns the serialized size. Note: In-memory size will be slightly larger than the serialized size.

1420 > func (c *ContextImpl) CacheSize() int { context.go

1421 > if !c.config.HistoryCacheLimitSizeBased {

1422 > return 1 context.go

1423 > }

1424 size := len(c.workflowKey.WorkflowID) + len(c.workflowKey.RunID) + len(c.workflowKey.NamespaceID)

1425 if c.MutableState != nil {

go.temporal.io/server/chasm/registry.go 70 covered LOC · 31 ranges

Open complete file

51 }

52

53 > func NewRegistry(logger log.Logger) *Registry { registry.go

54 > return &Registry{

55 > libraries: make(map[string]Library),

56 > rcByFqn: make(map[string]*RegistrableComponent),

57 > rcByID: make(map[uint32]*RegistrableComponent),

58 > rcByGoType: make(map[reflect.Type]*RegistrableComponent),

59 > rtByFqn: make(map[string]*RegistrableTask),

60 > rtByID: make(map[uint32]*RegistrableTask),

61 > rtByGoType: make(map[reflect.Type]*RegistrableTask),

62 > rcContextValues: make(map[any]valueWithFqn),

63 > nexusServices: make(map[string]*nexus.Service),

64 > NexusEndpointProcessor: NewNexusEndpointProcessor(),

65 > logger: logger,

66 > }

67 > }

68

69 > func (r *Registry) Register(lib Library) error { registry.go

70 > if err := r.validateName(lib.Name()); err != nil {

71 return err

72 }

73 > if _, ok := r.libraries[lib.Name()]; ok { registry.go

74 return fmt.Errorf("library %s is already registered", lib.Name())

75 }

76 > r.libraries[lib.Name()] = lib registry.go

77 >

78 > for _, c := range lib.Components() {

79 > if err := r.registerComponent(lib, c); err != nil { registry.go

80 return err

81 }

82 }

83 > for _, t := range lib.Tasks() { registry.go

84 if err := r.registerTask(lib, t); err != nil {

85 return err

87 }

88

89 > for _, svc := range lib.NexusServices() { registry.go

90 if err := r.registerNexusService(svc); err != nil {

91 return err

93 }

94

95 > for _, svc := range lib.NexusServiceProcessors() { registry.go

96 if err := r.NexusEndpointProcessor.RegisterServiceProcessor(svc); err != nil {

97 return err

99 }

100

101 > return nil registry.go

102 }

103

142 // This method should only be used by CHASM framework internal code,

143 // NOT CHASM library developers.

144 > func (r *Registry) ComponentIDFor(componentInstance any) (uint32, bool) { registry.go

145 > rc, ok := r.componentFor(componentInstance)

146 > if !ok {

147 return 0, false

148 }

149 > return rc.componentID, true registry.go

150 }

151

212 }

213

214 > func (r *Registry) componentFor(componentInstance any) (*RegistrableComponent, bool) { registry.go

215 > rc, ok := r.rcByGoType[reflect.TypeOf(componentInstance)]

216 > return rc, ok

217 > }

218

219 func (r *Registry) taskFor(taskInstance any) (*RegistrableTask, bool) {

222 }

223

224 > func (r *Registry) componentOf(componentGoType reflect.Type) (*RegistrableComponent, bool) { registry.go

225 > rc, ok := r.rcByGoType[componentGoType]

226 > return rc, ok

227 > }

228

229 func (r *Registry) taskOf(taskGoType reflect.Type) (*RegistrableTask, bool) {

235 lib namer,

236 rc *RegistrableComponent,

237 > ) error { registry.go

238 > if err := r.validate(rc); err != nil {

239 return err

240 }

241

242 > fqn, id, err := rc.registerToLibrary(lib) registry.go

243 > if err != nil {

244 return err

245 }

246

247 > if _, ok := r.rcByFqn[fqn]; ok { registry.go

248 return fmt.Errorf("component %s is already registered", fqn)

249 }

250

251 > if id == UnspecifiedArchetypeID { registry.go

252 return fmt.Errorf("component %s maps to a reserved archetype id %d, please use a different name", fqn, UnspecifiedArchetypeID)

253 }

254

255 > if existingComponent, ok := r.rcByID[id]; ok { registry.go

256 return fmt.Errorf("component ID %d collision between %s and %s", id, fqn, existingComponent.fqType())

257 }

258

259 > for key, value := range rc.contextValues { registry.go

260 if existingValue, ok := r.rcContextValues[key]; ok {

261 return fmt.Errorf("context value key %v registered by component %s conflicts with component %s", key, fqn, existingValue.fqn)

269 // rc.goType implements Component interface; therefore, it must be a struct.

270 // This check to protect against the interface itself being registered.

271 > if !(rc.goType.Kind() == reflect.Struct || registry.go

272 > (rc.goType.Kind() == reflect.Pointer && rc.goType.Elem().Kind() == reflect.Struct)) {

273 return fmt.Errorf("component type %s must be struct or pointer to struct", rc.goType.String())

274 }

275 > if _, ok := r.rcByGoType[rc.goType]; ok { registry.go

276 return fmt.Errorf("component type %s is already registered", rc.goType.String())

277 }

278 > r.warnUnmanagedFields(fqn, rc) registry.go

279 >

280 > r.rcByFqn[fqn] = rc

281 > r.rcByID[id] = rc

282 > r.rcByGoType[rc.goType] = rc

283 > return nil

284 }

285

286 > func (r *Registry) validate(rc *RegistrableComponent) error { registry.go

287 > if err := r.validateName(rc.componentType); err != nil {

288 return err

289 }

290 > return r.validateVisibilityBusinessIDAlias(rc) registry.go

291 }

292

332 }

333

334 > func (r *Registry) validateName(n string) error { registry.go

335 > if n == "" {

336 return errors.New("name must not be empty")

337 }

338 > if !nameValidator.MatchString(n) { registry.go

339 return fmt.Errorf("name %s is invalid. name must follow golang identifier rules: %s", n, nameValidator.String())

340 }

341 > return nil registry.go

342 }

343

344 > func (r *Registry) validateVisibilityBusinessIDAlias(rc *RegistrableComponent) error { registry.go

345 > if !hasVisibilityField(rc.goType) {

346 > return nil registry.go

347 > }

348 // Archetypes that contain a Field[*Visibility] must specify WithBusinessIDAlias.

349 if !rc.hasBusinessIDAlias() {

353 }

354

355 > func (r *Registry) warnUnmanagedFields(fqn string, rc *RegistrableComponent) { registry.go

356 > var unmanagedFields []string

357 > for f := range unmanagedFieldsOf(rc.goType) {

358 unmanagedFields = append(unmanagedFields, fmt.Sprintf("%s %s", f.name, f.typ))

359 }

360 > if len(unmanagedFields) > 0 { registry.go

361 r.logger.Info(fmt.Sprintf(

362 "Warning: CHASM component %s declares state fields that won't be managed by CHASM:\n\t%s",

go.temporal.io/server/api/persistence/v1/hsm.pb.go 65 covered LOC · 18 ranges

Open complete file

147 func (*StateMachineMap) ProtoMessage() {}

148

149 > func (x *StateMachineMap) ProtoReflect() protoreflect.Message { hsm.pb.go

150 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[1]

151 > if x != nil {

152 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

153 if ms.LoadMessageInfo() == nil {

156 return ms

157 }

158 > return mi.MessageOf(x) hsm.pb.go

159 }

160

272 func (*StateMachineRef) ProtoMessage() {}

273

274 > func (x *StateMachineRef) ProtoReflect() protoreflect.Message { hsm.pb.go

275 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[3]

276 > if x != nil {

277 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

278 if ms.LoadMessageInfo() == nil {

281 return ms

282 }

283 > return mi.MessageOf(x) hsm.pb.go

284 }

285

349 func (*StateMachineTaskInfo) ProtoMessage() {}

350

351 > func (x *StateMachineTaskInfo) ProtoReflect() protoreflect.Message { hsm.pb.go

352 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[4]

353 > if x != nil {

354 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

355 if ms.LoadMessageInfo() == nil {

358 return ms

359 }

360 > return mi.MessageOf(x) hsm.pb.go

361 }

362

416 func (*StateMachineTimerGroup) ProtoMessage() {}

417

418 > func (x *StateMachineTimerGroup) ProtoReflect() protoreflect.Message { hsm.pb.go

419 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[5]

420 > if x != nil {

421 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

422 if ms.LoadMessageInfo() == nil {

425 return ms

426 }

427 > return mi.MessageOf(x) hsm.pb.go

428 }

429

478 func (*VersionedTransition) ProtoMessage() {}

479

480 > func (x *VersionedTransition) ProtoReflect() protoreflect.Message { hsm.pb.go

481 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[6]

482 > if x != nil {

483 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

484 if ms.LoadMessageInfo() == nil {

487 return ms

488 }

489 > return mi.MessageOf(x) hsm.pb.go

490 }

491

495 }

496

497 > func (x *VersionedTransition) GetNamespaceFailoverVersion() int64 { hsm.pb.go

498 > if x != nil {

499 > return x.NamespaceFailoverVersion hsm.pb.go

500 > }

501 > return 0 hsm.pb.go

502 }

503

504 > func (x *VersionedTransition) GetTransitionCount() int64 { hsm.pb.go

505 > if x != nil {

506 > return x.TransitionCount hsm.pb.go

507 > }

508 return 0

509 }

531 func (*StateMachineTombstoneBatch) ProtoMessage() {}

532

533 > func (x *StateMachineTombstoneBatch) ProtoReflect() protoreflect.Message { hsm.pb.go

534 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[7]

535 > if x != nil {

536 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

537 if ms.LoadMessageInfo() == nil {

540 return ms

541 }

542 > return mi.MessageOf(x) hsm.pb.go

543 }

544

895 }

896

897 > func init() { file_temporal_server_api_persistence_v1_hsm_proto_init() } hsm.pb.go

898 > func file_temporal_server_api_persistence_v1_hsm_proto_init() {

899 > if File_temporal_server_api_persistence_v1_hsm_proto != nil {

900 > return

901 > }

902 > file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[8].OneofWrappers = []any{

903 > (*StateMachineTombstone_ActivityScheduledEventId)(nil),

904 > (*StateMachineTombstone_TimerId)(nil),

905 > (*StateMachineTombstone_ChildExecutionInitiatedEventId)(nil),

906 > (*StateMachineTombstone_RequestCancelInitiatedEventId)(nil),

907 > (*StateMachineTombstone_SignalExternalInitiatedEventId)(nil),

908 > (*StateMachineTombstone_UpdateId)(nil),

909 > (*StateMachineTombstone_StateMachinePath)(nil),

910 > (*StateMachineTombstone_ChasmNodePath)(nil),

911 > }

912 > type x struct{}

913 > out := protoimpl.TypeBuilder{

914 > File: protoimpl.DescBuilder{

915 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

916 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_hsm_proto_rawDesc), len(file_temporal_server_api_persistence_v1_hsm_proto_rawDesc)),

917 > NumEnums: 0,

918 > NumMessages: 12,

919 > NumExtensions: 0,

920 > NumServices: 0,

921 > },

922 > GoTypes: file_temporal_server_api_persistence_v1_hsm_proto_goTypes,

923 > DependencyIndexes: file_temporal_server_api_persistence_v1_hsm_proto_depIdxs,

924 > MessageInfos: file_temporal_server_api_persistence_v1_hsm_proto_msgTypes,

925 > }.Build()

926 > File_temporal_server_api_persistence_v1_hsm_proto = out.File

927 > file_temporal_server_api_persistence_v1_hsm_proto_goTypes = nil

928 > file_temporal_server_api_persistence_v1_hsm_proto_depIdxs = nil

929 }

go.temporal.io/server/service/history/shard/task_key_generator.go 60 covered LOC · 13 ranges

Open complete file

39 logger log.Logger,

40 renewRangeIDFn renewRangeIDFn,

41 > ) *taskKeyGenerator { task_key_generator.go

42 > return &taskKeyGenerator{

43 > nextTaskID: taskIDUninitialized,

44 > exclusiveMaxTaskID: taskIDUninitialized,

45 > rangeSizeBits: rangeSizeBits,

46 > timeSource: timeSource,

47 > logger: logger,

48 > renewRangeIDFn: renewRangeIDFn,

49 > }

50 > }

51

52 func (a *taskKeyGenerator) setTaskKeys(

53 taskMaps ...map[tasks.Category][]tasks.Task,

54 > ) error { task_key_generator.go

55 > now := a.timeSource.Now()

56 > // TODO: Truncation here is just to make sure task scheduled time has the same precision as the old logic.

57 > // Remove this truncation once we validate the rest of the code can worker correctly with higher precision.

58 > a.setTaskMinScheduledTime(now.Truncate(common.ScheduledTaskMinPrecision))

59 >

60 > for _, taskMap := range taskMaps {

61 > for category, tasksByCategory := range taskMap {

62 > isScheduledTask := category.Type() == tasks.CategoryTypeScheduled task_key_generator.go

63 > for _, task := range tasksByCategory {

64 > id, err := a.generateTaskID()

65 > if err != nil {

66 return err

67 }

68 > task.SetTaskID(id) task_key_generator.go

69 >

70 > taskScheduledTime := now

71 > if isScheduledTask {

72 // Persistence might loss precision when saving to DB.

73 // Make the task scheduled time to have the same precision as DB here,

94 }

95 }

96 > task.SetVisibilityTime(taskScheduledTime) task_key_generator.go

97 >

98 > a.logger.Debug("Assigning new task key",

99 > tag.WorkflowNamespaceID(task.GetNamespaceID()),

100 > tag.WorkflowID(task.GetWorkflowID()),

101 > tag.WorkflowRunID(task.GetRunID()),

102 > tag.TaskType(task.GetType()),

103 > tag.TaskID(id),

104 > tag.Timestamp(task.GetVisibilityTime()),

105 > tag.CursorTimestamp(a.taskMinScheduledTime),

106 > )

107 }

108 }

109 }

110

111 > return nil task_key_generator.go

112 }

113

114 func (a *taskKeyGenerator) peekTaskKey(

115 category tasks.Category,

116 > ) tasks.Key { task_key_generator.go

117 > switch category.Type() {

118 > case tasks.CategoryTypeImmediate: task_key_generator.go

119 > return tasks.NewImmediateKey(a.nextTaskID)

120 case tasks.CategoryTypeScheduled:

121 return tasks.NewKey(

149 }

150

151 > func (a *taskKeyGenerator) setRangeID(rangeID int64) { task_key_generator.go

152 > a.nextTaskID = rangeID << a.rangeSizeBits

153 > a.exclusiveMaxTaskID = (rangeID + 1) << a.rangeSizeBits

154 >

155 > a.logger.Info("Task key range updated",

156 > tag.Number(a.nextTaskID),

157 > tag.NextNumber(a.exclusiveMaxTaskID),

158 > )

159 > }

160

161 func (a *taskKeyGenerator) setTaskMinScheduledTime(

162 taskMinScheduledTime time.Time,

163 > ) { task_key_generator.go

164 > a.taskMinScheduledTime = util.MaxTime(a.taskMinScheduledTime, taskMinScheduledTime)

165 > }

166

167 > func (a *taskKeyGenerator) generateTaskID() (int64, error) { task_key_generator.go

168 > if a.nextTaskID == taskIDUninitialized {

169 a.logger.Panic("Range id is not initialized before generating task id")

170 }

171

172 > if a.nextTaskID == a.exclusiveMaxTaskID { task_key_generator.go

173 if err := a.renewRangeIDFn(); err != nil {

174 return taskIDUninitialized, err

180 }

181

182 > taskID := a.nextTaskID task_key_generator.go

183 > a.nextTaskID++

184 > return taskID, nil

185 }

go.temporal.io/server/service/history/shard/task_request_tracker.go 58 covered LOC · 16 ranges

Open complete file

24 )

25

26 > func newTaskRequestTracker(registry tasks.TaskCategoryRegistry) *taskRequestTracker { task_request_tracker.go

27 > outstandingTaskKeys := make(map[tasks.Category]map[tasks.Key]struct{})

28 > for _, category := range registry.GetCategories() {

29 > outstandingTaskKeys[category] = make(map[tasks.Key]struct{})

30 > }

31 > return &taskRequestTracker{

32 > pendingTaskKeys: outstandingTaskKeys,

33 > }

34 }

35

36 func (t *taskRequestTracker) track(

37 taskMaps ...map[tasks.Category][]tasks.Task,

38 > ) taskRequestCompletionFn { task_request_tracker.go

39 > minKeyByCategory := make(map[tasks.Category]tasks.Key)

40 > for _, taskMap := range taskMaps {

41 > for category, tasksPerCategory := range taskMap {

42 > minKey := tasks.MaximumKey task_request_tracker.go

43 > for _, task := range tasksPerCategory {

44 > if task.GetKey().CompareTo(minKey) < 0 {

45 > minKey = task.GetKey()

46 > }

47 }

48 > if minKey.CompareTo(tasks.MaximumKey) == 0 { task_request_tracker.go

49 continue

50 }

51

52 > if _, ok := minKeyByCategory[category]; !ok { task_request_tracker.go

53 > minKeyByCategory[category] = minKey

54 > } else {

55 minKeyByCategory[category] = tasks.MinKey(minKeyByCategory[category], minKey)

56 }

58 }

59

60 > t.Lock() task_request_tracker.go

61 > defer t.Unlock()

62 >

63 > t.inflightRequestCount++

64 >

65 > for category, minKey := range minKeyByCategory {

66 > t.pendingTaskKeys[category][minKey] = struct{}{} task_request_tracker.go

67 > }

68

69 > return func(writeErr error) { task_request_tracker.go

70 > t.Lock() task_request_tracker.go

71 > defer t.Unlock()

72 >

73 > // Task key is not pending only when we get a definitive result from persistence.

74 > // This result can be either a success or a error that guarantees the task with that key

75 > // will not be persisted.

76 > if writeErr == nil || !persistence.OperationPossiblySucceeded(writeErr) {

77 > // we can only remove the task from the pending task list if we are sure it was inserted task_request_tracker.go

78 > // or the insertion is guaranteed to have failed

79 > for category, minKey := range minKeyByCategory {

80 > delete(t.pendingTaskKeys[category], minKey) task_request_tracker.go

81 > }

82 }

83

84 // While task key might still be pending, the request is completed and no longer inflight

85 > t.inflightRequestCount-- task_request_tracker.go

86 > if t.inflightRequestCount == 0 {

87 > t.closeWaitChannelsLocked() task_request_tracker.go

88 > }

89 }

90 }

130 }

131

132 > func (t *taskRequestTracker) clear() { task_request_tracker.go

133 > t.Lock()

134 > defer t.Unlock()

135 >

136 > for category := range t.pendingTaskKeys {

137 > t.pendingTaskKeys[category] = make(map[tasks.Key]struct{})

138 > }

139 > t.inflightRequestCount = 0

140 > t.closeWaitChannelsLocked()

141 }

142

143 > func (t *taskRequestTracker) closeWaitChannelsLocked() { task_request_tracker.go

144 > for _, waitCh := range t.waitChannels {

145 close(waitCh)

146 }

147 > t.waitChannels = nil task_request_tracker.go

148 }

go.temporal.io/server/common/testing/testvars/test_vars.go 56 covered LOC · 17 ranges

Open complete file

37 )

38

39 > func New(testNamer testNamer) *TestVars { test_vars.go

40 > return newFromName(testNamer.Name())

41 > }

42

43 > func newFromName(testName string) *TestVars { test_vars.go

44 > th := hash(testName)

45 > return &TestVars{

46 > testName: testName,

47 > testHash: th,

48 > an: newAny(testName, th),

49 > }

50 > }

51

52 > func getOrCreate[T any](tv *TestVars, key string, initialValGen func(key string) T, valNSetter func(val T, n int) T) T { test_vars.go

53 > v, _ := tv.values.LoadOrStore(key, initialValGen(key))

54 >

55 > n, ok := tv.numbers.Load(key)

56 > if !ok {

57 > //revive:disable-next-line:unchecked-type-assertion test_vars.go

58 > return v.(T)

59 > }

60

61 //revive:disable-next-line:unchecked-type-assertion

85 }

86

87 > func (tv *TestVars) uniqueString(key string) string { test_vars.go

88 > return fmt.Sprintf("%s_%s", tv.testName, key)

89 > }

90

91 > func (tv *TestVars) uuidString(_ string) string { test_vars.go

92 > return uuid.NewString()

93 > }

94

95 > func (tv *TestVars) emptyString(_ string) string { test_vars.go

96 > return ""

97 > }

98

99 > func (tv *TestVars) clone() *TestVars { test_vars.go

100 > tv2 := newFromName(tv.testName)

101 > tv.values.Range(func(key, value any) bool {

102 tv2.values.Store(key, value)

103 return true

104 })

105 > tv.numbers.Range(func(key, value any) bool { test_vars.go

106 tv2.numbers.Store(key, value)

107 return true

108 })

109

110 > return tv2 test_vars.go

111 }

112 > func (tv *TestVars) cloneSetVal(key string, val any) *TestVars { test_vars.go

113 > tv2 := tv.clone()

114 > tv2.values.Store(key, val)

115 > return tv2

116 > }

117

118 func (tv *TestVars) cloneSetN(key string, n int) *TestVars {

186 }

187

188 > func (tv *TestVars) WorkflowID() string { test_vars.go

189 > return getOrCreate(tv, "workflow_id", tv.uniqueString, tv.stringNSetter)

190 > }

191

192 func (tv *TestVars) WithWorkflowIDNumber(n int) *TestVars {

197 // This is to simplify the usage of WorkflowExecution() which most of the time

198 // doesn't need RunID. Otherwise, RunID can be set explicitly using WithRunID.

199 > func (tv *TestVars) RunID() string { test_vars.go

200 > return getOrCreate(tv, "run_id", tv.emptyString, tv.uuidNSetter)

201 > }

202

203 > func (tv *TestVars) WithRunID(runID string) *TestVars { test_vars.go

204 > return tv.cloneSetVal("run_id", runID)

205 > }

206

207 func (tv *TestVars) WorkflowExecution() *commonpb.WorkflowExecution {

212 }

213

214 > func (tv *TestVars) RequestID() string { test_vars.go

215 > return getOrCreate(tv, "request_id", tv.uuidString, tv.uuidNSetter)

216 > }

217

218 func (tv *TestVars) WithRequestID(requestID string) *TestVars {

346 }

347

348 > func (tv *TestVars) ActivityID() string { test_vars.go

349 > return getOrCreate(tv, "activity_id", tv.uniqueString, tv.stringNSetter)

350 > }

351

352 func (tv *TestVars) WithActivityIDNumber(n int) *TestVars {

440

441 // ----------- Generic methods ------------

442 > func (tv *TestVars) Any() Any { test_vars.go

443 > return tv.an

444 > }

445

446 func (tv *TestVars) Global() Global {

go.temporal.io/server/common/log/tag/tags.go 54 covered LOC · 18 ranges

Open complete file

58

59 // Timestamp returns tag for Timestamp

60 > func Timestamp(timestamp time.Time) ZapTag { tags.go

61 > return NewTimeTag("timestamp", timestamp)

62 > }

63

64 // RequestID returns tag for RequestID

70

71 // WorkflowAction returns tag for WorkflowAction

72 > func workflowAction(action string) ZapTag { tags.go

73 > return NewStringTag("wf-action", action)

74 > }

75

76 // WorkflowListFilterType returns tag for WorkflowListFilterType

77 > func workflowListFilterType(listFilterType string) ZapTag { tags.go

78 > return NewStringTag("wf-list-filter-type", listFilterType)

79 > }

80

81 // general

108 // WorkflowID returns tag for WorkflowID

109 // TODO: Rename to BusinessID.

110 > func WorkflowID(workflowID string) ZapTag { tags.go

111 > return NewStringTag(WorkflowIDKey, workflowID)

112 > }

113

114 // WorkflowType returns tag for WorkflowType

124 // WorkflowRunID returns tag for WorkflowRunID

125 // TODO: Rename to RunID

126 > func WorkflowRunID(runID string) ZapTag { tags.go

127 > return NewStringTag(WorkflowRunIDKey, runID)

128 > }

129

130 // WorkflowNewRunID returns tag for WorkflowNewRunID

187 // WorkflowNamespaceID returns tag for WorkflowNamespaceID

188 // TODO: Rename to NamespaceID

189 > func WorkflowNamespaceID(namespaceID string) ZapTag { tags.go

190 > return NewStringTag("wf-namespace-id", namespaceID)

191 > }

192

193 // WorkflowNamespace returns tag for WorkflowNamespace

376

377 // Component returns tag for Component

378 > func component(component string) ZapTag { tags.go

379 > return NewStringTag("component", component)

380 > }

381

382 // Lifecycle returns tag for Lifecycle

383 > func lifecycle(lifecycle string) ZapTag { tags.go

384 > return NewStringTag("lifecycle", lifecycle)

385 > }

386

387 // StoreOperation returns tag for StoreOperation

388 > func storeOperation(storeOperation string) ZapTag { tags.go

389 > return NewStringTag("store-operation", storeOperation)

390 > }

391

392 // OperationResult returns tag for OperationResult

393 > func operationResult(operationResult string) ZapTag { tags.go

394 > return NewStringTag("operation-result", operationResult)

395 > }

396

397 // ErrorType returns tag for ErrorType

401

402 // errorType returns tag for ErrorType given a string

403 > func errorType(errorType string) ZapTag { tags.go

404 > return NewStringTag("error-type", errorType)

405 > }

406

407 // Shardupdate returns tag for Shardupdate

408 > func shardupdate(shardupdate string) ZapTag { tags.go

409 > return NewStringTag("shard-update", shardupdate)

410 > }

411

412 // scope returns a tag for scope

413 // Pre-defined scope tags are in values.go.

414 > func scope(scope string) ZapTag { tags.go

415 > return NewStringTag("scope", scope)

416 > }

417

418 // general

489

490 // CursorTimestamp returns tag for CursorTimestamp

491 > func CursorTimestamp(timestamp time.Time) ZapTag { tags.go

492 > return NewTimeTag("cursor-timestamp", timestamp)

493 > }

494

495 // MetricScope returns tag for MetricScope

524

525 // Number returns tag for Number

526 > func Number(n int64) ZapTag { tags.go

527 > return NewInt64("number", n)

528 > }

529

530 // NextNumber returns tag for NextNumber

531 > func NextNumber(n int64) ZapTag { tags.go

532 > return NewInt64("next-number", n)

533 > }

534

535 // ServerName returns tag for ServerName

620

621 // TaskID returns tag for TaskID

622 > func TaskID(taskID int64) ZapTag { tags.go

623 > return NewInt64("queue-task-id", taskID)

624 > }

625

626 // TaskKey returns tag for TaskKey

634 }

635

636 > func TaskType(taskType enumsspb.TaskType) ZapTag { tags.go

637 > return NewStringTag("queue-task-type", taskType.String())

638 > }

639

640 func TaskCategoryID(taskCategoryID int) ZapTag {

go.temporal.io/server/common/cluster/metadata_mock.go 50 covered LOC · 11 ranges

Open complete file

30

31 // NewMockMetadata creates a new mock instance.

32 > func NewMockMetadata(ctrl *gomock.Controller) *MockMetadata { metadata_mock.go

33 > mock := &MockMetadata{ctrl: ctrl}

34 > mock.recorder = &MockMetadataMockRecorder{mock}

35 > return mock

36 > }

37

38 // EXPECT returns an object that allows the caller to indicate expected use.

39 > func (m *MockMetadata) EXPECT() *MockMetadataMockRecorder { metadata_mock.go

40 > return m.recorder

41 > }

42

43 // ClusterNameForFailoverVersion mocks base method.

44 > func (m *MockMetadata) ClusterNameForFailoverVersion(isGlobalNamespace bool, failoverVersion int64) string { metadata_mock.go

45 > m.ctrl.T.Helper()

46 > ret := m.ctrl.Call(m, "ClusterNameForFailoverVersion", isGlobalNamespace, failoverVersion)

47 > ret0, _ := ret[0].(string)

48 > return ret0

49 > }

50

51 // ClusterNameForFailoverVersion indicates an expected call of ClusterNameForFailoverVersion.

52 > func (mr *MockMetadataMockRecorder) ClusterNameForFailoverVersion(isGlobalNamespace, failoverVersion any) *gomock.Call { metadata_mock.go

53 > mr.mock.ctrl.T.Helper()

54 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNameForFailoverVersion", reflect.TypeOf((*MockMetadata)(nil).ClusterNameForFailoverVersion), isGlobalNamespace, failoverVersion)

55 > }

56

57 // GetAllClusterInfo mocks base method.

64

65 // GetAllClusterInfo indicates an expected call of GetAllClusterInfo.

66 > func (mr *MockMetadataMockRecorder) GetAllClusterInfo() *gomock.Call { metadata_mock.go

67 > mr.mock.ctrl.T.Helper()

68 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllClusterInfo", reflect.TypeOf((*MockMetadata)(nil).GetAllClusterInfo))

69 > }

70

71 // GetClusterID mocks base method.

72 > func (m *MockMetadata) GetClusterID() int64 { metadata_mock.go

73 > m.ctrl.T.Helper()

74 > ret := m.ctrl.Call(m, "GetClusterID")

75 > ret0, _ := ret[0].(int64)

76 > return ret0

77 > }

78

79 // GetClusterID indicates an expected call of GetClusterID.

80 > func (mr *MockMetadataMockRecorder) GetClusterID() *gomock.Call { metadata_mock.go

81 > mr.mock.ctrl.T.Helper()

82 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterID", reflect.TypeOf((*MockMetadata)(nil).GetClusterID))

83 > }

84

85 // GetCurrentClusterName mocks base method.

86 > func (m *MockMetadata) GetCurrentClusterName() string { metadata_mock.go

87 > m.ctrl.T.Helper()

88 > ret := m.ctrl.Call(m, "GetCurrentClusterName")

89 > ret0, _ := ret[0].(string)

90 > return ret0

91 > }

92

93 // GetCurrentClusterName indicates an expected call of GetCurrentClusterName.

94 > func (mr *MockMetadataMockRecorder) GetCurrentClusterName() *gomock.Call { metadata_mock.go

95 > mr.mock.ctrl.T.Helper()

96 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentClusterName", reflect.TypeOf((*MockMetadata)(nil).GetCurrentClusterName))

97 > }

98

99 // GetFailoverVersionIncrement mocks base method.

162

163 // IsGlobalNamespaceEnabled indicates an expected call of IsGlobalNamespaceEnabled.

164 > func (mr *MockMetadataMockRecorder) IsGlobalNamespaceEnabled() *gomock.Call { metadata_mock.go

165 > mr.mock.ctrl.T.Helper()

166 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsGlobalNamespaceEnabled", reflect.TypeOf((*MockMetadata)(nil).IsGlobalNamespaceEnabled))

167 > }

168

169 // IsMasterCluster mocks base method.

190

191 // IsVersionFromSameCluster indicates an expected call of IsVersionFromSameCluster.

192 > func (mr *MockMetadataMockRecorder) IsVersionFromSameCluster(version1, version2 any) *gomock.Call { metadata_mock.go

193 > mr.mock.ctrl.T.Helper()

194 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsVersionFromSameCluster", reflect.TypeOf((*MockMetadata)(nil).IsVersionFromSameCluster), version1, version2)

195 > }

196

197 // RegisterMetadataChangeCallback mocks base method.

go.temporal.io/server/common/persistence/data_interfaces_mock.go 48 covered LOC · 10 ranges

Open complete file

67

68 // NewMockShardManager creates a new mock instance.

69 > func NewMockShardManager(ctrl *gomock.Controller) *MockShardManager { data_interfaces_mock.go

70 > mock := &MockShardManager{ctrl: ctrl}

71 > mock.recorder = &MockShardManagerMockRecorder{mock}

72 > return mock

73 > }

74

75 // EXPECT returns an object that allows the caller to indicate expected use.

160

161 // NewMockExecutionManager creates a new mock instance.

162 > func NewMockExecutionManager(ctrl *gomock.Controller) *MockExecutionManager { data_interfaces_mock.go

163 > mock := &MockExecutionManager{ctrl: ctrl}

164 > mock.recorder = &MockExecutionManagerMockRecorder{mock}

165 > return mock

166 > }

167

168 // EXPECT returns an object that allows the caller to indicate expected use.

169 > func (m *MockExecutionManager) EXPECT() *MockExecutionManagerMockRecorder { data_interfaces_mock.go

170 > return m.recorder

171 > }

172

173 // AddHistoryTasks mocks base method.

257

258 // CreateWorkflowExecution mocks base method.

259 > func (m *MockExecutionManager) CreateWorkflowExecution(ctx context.Context, request *CreateWorkflowExecutionRequest) (*CreateWorkflowExecutionResponse, error) { data_interfaces_mock.go

260 > m.ctrl.T.Helper()

261 > ret := m.ctrl.Call(m, "CreateWorkflowExecution", ctx, request)

262 > ret0, _ := ret[0].(*CreateWorkflowExecutionResponse)

263 > ret1, _ := ret[1].(error)

264 > return ret0, ret1

265 > }

266

267 // CreateWorkflowExecution indicates an expected call of CreateWorkflowExecution.

268 > func (mr *MockExecutionManagerMockRecorder) CreateWorkflowExecution(ctx, request any) *gomock.Call { data_interfaces_mock.go

269 > mr.mock.ctrl.T.Helper()

270 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).CreateWorkflowExecution), ctx, request)

271 > }

272

273 // DeleteCurrentWorkflowExecution mocks base method.

381

382 // GetHistoryBranchUtil indicates an expected call of GetHistoryBranchUtil.

383 > func (mr *MockExecutionManagerMockRecorder) GetHistoryBranchUtil() *gomock.Call { data_interfaces_mock.go

384 > mr.mock.ctrl.T.Helper()

385 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryBranchUtil", reflect.TypeOf((*MockExecutionManager)(nil).GetHistoryBranchUtil))

386 > }

387

388 // GetHistoryTasks mocks base method.

635

636 // NewMockTaskManager creates a new mock instance.

637 > func NewMockTaskManager(ctrl *gomock.Controller) *MockTaskManager { data_interfaces_mock.go

638 > mock := &MockTaskManager{ctrl: ctrl}

639 > mock.recorder = &MockTaskManagerMockRecorder{mock}

640 > return mock

641 > }

642

643 // EXPECT returns an object that allows the caller to indicate expected use.

878

879 // NewMockMetadataManager creates a new mock instance.

880 > func NewMockMetadataManager(ctrl *gomock.Controller) *MockMetadataManager { data_interfaces_mock.go

881 > mock := &MockMetadataManager{ctrl: ctrl}

882 > mock.recorder = &MockMetadataManagerMockRecorder{mock}

883 > return mock

884 > }

885

886 // EXPECT returns an object that allows the caller to indicate expected use.

1073

1074 // NewMockClusterMetadataManager creates a new mock instance.

1075 > func NewMockClusterMetadataManager(ctrl *gomock.Controller) *MockClusterMetadataManager { data_interfaces_mock.go

1076 > mock := &MockClusterMetadataManager{ctrl: ctrl}

1077 > mock.recorder = &MockClusterMetadataManagerMockRecorder{mock}

1078 > return mock

1079 > }

1080

1081 // EXPECT returns an object that allows the caller to indicate expected use.

1240

1241 // NewMockNexusEndpointManager creates a new mock instance.

1242 > func NewMockNexusEndpointManager(ctrl *gomock.Controller) *MockNexusEndpointManager { data_interfaces_mock.go

1243 > mock := &MockNexusEndpointManager{ctrl: ctrl}

1244 > mock.recorder = &MockNexusEndpointManagerMockRecorder{mock}

1245 > return mock

1246 > }

1247

1248 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/service/history/hsm/tree.go 47 covered LOC · 14 ranges

Open complete file

204 children map[string]*persistencespb.StateMachineMap,

205 backend NodeBackend,

206 > ) (*Node, error) { tree.go

207 > def, ok := registry.Machine(t)

208 > if !ok {

209 return nil, fmt.Errorf("%w: state machine for type: %v", ErrNotRegistered, t)

210 }

211 > serialized, err := def.Serialize(data) tree.go

212 > if err != nil {

213 return nil, err

214 }

215 > return &Node{ tree.go

216 > definition: def,

217 > registry: registry,

218 > persistence: &persistencespb.StateMachineNode{

219 > Children: children,

220 > Data: serialized,

221 > InitialVersionedTransition: &persistencespb.VersionedTransition{},

222 > LastUpdateVersionedTransition: &persistencespb.VersionedTransition{},

223 > TransitionCount: 0,

224 > },

225 > cache: &cachedMachine{

226 > dataLoaded: true,

227 > data: data,

228 > children: make(map[Key]*Node),

229 > },

230 > backend: backend,

231 > opLog: make(OperationLog, 0),

232 > }, nil

233 }

234

235 // Dirty returns true if any of the tree's state machines have transitioned.

236 > func (n *Node) Dirty() bool { tree.go

237 > if n.cache.dirty {

238 return true

239 }

240 > for _, child := range n.cache.children { tree.go

241 if child.Dirty() {

242 return true

243 }

244 }

245 > return false tree.go

246 }

247

262 // deleted. For details on compaction rules, see OperationLog.compact().

263 // This method must be called on the root node only.

264 > func (n *Node) OpLog() (OperationLog, error) { tree.go

265 > if n.Parent != nil {

266 return nil, fmt.Errorf("can only be called from root node")

267 }

268

269 > compacted := n.opLog.compact() tree.go

270 > return compacted, nil

271 }

272

274 // This should be called at the end of every transaction where the transitions are performed to avoid emitting duplicate

275 // transition outputs.

276 > func (n *Node) ClearTransactionState() { tree.go

277 > n.root().opLog = nil

278 >

279 > n.cache.dirty = false

280 > for _, child := range n.cache.children {

281 child.ClearTransactionState()

282 }

515 // InternalRepr returns the internal persistence representation of this node.

516 // Meant to be used by the framework, **not** by components.

517 > func (n *Node) InternalRepr() *persistencespb.StateMachineNode { tree.go

518 > return n.persistence

519 > }

520

521 // CompareState compare current node state with the incoming node state.

705 }

706

707 > func (n *Node) root() *Node { tree.go

708 > root := n

709 > for root.Parent != nil {

710 root = root.Parent

711 }

712 > return root tree.go

713 }

714

727 // - If the target of the operation is deleted, only its DeleteOperation is kept

728 // - Otherwise, the operation is included

729 > func (ol OperationLog) compact() OperationLog { tree.go

730 > if len(ol) == 0 {

731 > return ol tree.go

732 > }

733

734 root := newOpNode(Key{})

go.temporal.io/server/common/dynamicconfig/collection.go 46 covered LOC · 10 ranges

Open complete file

111 // NewCollection creates a new collection. For subscriptions to work, you must call Start/Stop.

112 // Get will work without Start/Stop.

113 > func NewCollection(client Client, logger log.Logger) *Collection { collection.go

114 > // Do this at the first convenient place we have a logger:

115 > logSharedStructureWarnings(logger)

116 >

117 > return &Collection{

118 > client: client,

119 > logger: logger,

120 > errCount: -1,

121 > subscriptions: make(map[Key]map[int]any),

122 > convertCache: new(sync.Map),

123 > indexCache: new(sync.Map),

124 > }

125 > }

126

127 func (c *Collection) Start() {

212 cvs []ConstrainedValue,

213 precedence []Constraints,

214 > ) (*ConstrainedValue, error) { collection.go

215 > if len(cvs) == 0 {

216 > return nil, errKeyNotPresent collection.go

217 > } else if len(cvs) > constraintsCacheThreshold && len(cvs) <= math.MaxInt32 { collection.go

218 return findMatchWithCache(cache, cvs, precedence)

219 }

279 convert func(value any) (T, error),

280 precedence []Constraints,

281 > ) T { collection.go

282 > cvs := c.client.GetValue(key)

283 > v, _ := matchAndConvertCvs(c, key, def, convert, precedence, cvs)

284 > return v

285 > }

286

287 func matchAndConvertCvs[T any](

292 precedence []Constraints,

293 cvs []ConstrainedValue,

294 > ) (T, any) { collection.go

295 > cvp, err := findMatch(c.indexCache, cvs, precedence)

296 > if err != nil {

297 > // couldn't find a constrained match, use default collection.go

298 > return def, usingDefaultValue

299 > }

300

301 typedVal, err := convertWithCache(c, key, convert, cvp)

676 // treat the fields independently), or the zero value of its type (if you want to treat the fields

677 // as a group and default unset fields to zero).

678 > func ConvertStructure[T any](def T) func(v any) (T, error) { collection.go

679 > return func(v any) (T, error) {

680 > // if we already have the right type, no conversion is necessary

681 > if typedV, ok := v.(T); ok {

682 return typedV, nil

683 }

685 // Deep-copy the default and decode over it. This allows using e.g. a struct with some

686 // default fields filled in and a config that only set some fields.

687 > out := deepCopyForMapstructure(def) collection.go

688 >

689 > dec, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{

690 > Result: &out,

691 > DecodeHook: mapstructure.ComposeDecodeHookFunc(

692 > mapstructureHookDuration,

693 > mapstructureHookTimestamp,

694 > mapstructureHookProtoEnum,

695 > mapstructureHookGeneric,

696 > ),

697 > })

698 > if err != nil {

699 return out, err

700 }

701 > err = dec.Decode(v) collection.go

702 > return out, err

703 }

704 }

go.temporal.io/server/api/historyservice/v1/request_response.pb.go 45 covered LOC · 1 range

Open complete file

11956 }

11957

11958 > func init() { file_temporal_server_api_historyservice_v1_request_response_proto_init() } request_response.pb.go

11959 > func file_temporal_server_api_historyservice_v1_request_response_proto_init() {

11960 > if File_temporal_server_api_historyservice_v1_request_response_proto != nil {

11961 > return

11962 > }

11963 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[107].OneofWrappers = []any{

11964 > (*StreamWorkflowReplicationMessagesRequest_SyncReplicationState)(nil),

11965 > }

11966 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[108].OneofWrappers = []any{

11967 > (*StreamWorkflowReplicationMessagesResponse_Messages)(nil),

11968 > }

11969 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[134].OneofWrappers = []any{

11970 > (*CompleteNexusOperationChasmRequest_Success)(nil),

11971 > (*CompleteNexusOperationChasmRequest_Failure)(nil),

11972 > }

11973 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[136].OneofWrappers = []any{

11974 > (*CompleteNexusOperationRequest_Success)(nil),

11975 > (*CompleteNexusOperationRequest_Failure)(nil),

11976 > }

11977 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[162].OneofWrappers = []any{

11978 > (*ExecuteMultiOperationRequest_Operation_StartWorkflow)(nil),

11979 > (*ExecuteMultiOperationRequest_Operation_UpdateWorkflow)(nil),

11980 > }

11981 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[163].OneofWrappers = []any{

11982 > (*ExecuteMultiOperationResponse_Response_StartWorkflow)(nil),

11983 > (*ExecuteMultiOperationResponse_Response_UpdateWorkflow)(nil),

11984 > }

11985 > type x struct{}

11986 > out := protoimpl.TypeBuilder{

11987 > File: protoimpl.DescBuilder{

11988 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

11989 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_historyservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_historyservice_v1_request_response_proto_rawDesc)),

11990 > NumEnums: 0,

11991 > NumMessages: 171,

11992 > NumExtensions: 1,

11993 > NumServices: 0,

11994 > },

11995 > GoTypes: file_temporal_server_api_historyservice_v1_request_response_proto_goTypes,

11996 > DependencyIndexes: file_temporal_server_api_historyservice_v1_request_response_proto_depIdxs,

11997 > MessageInfos: file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes,

11998 > ExtensionInfos: file_temporal_server_api_historyservice_v1_request_response_proto_extTypes,

11999 > }.Build()

12000 > File_temporal_server_api_historyservice_v1_request_response_proto = out.File

12001 > file_temporal_server_api_historyservice_v1_request_response_proto_goTypes = nil

12002 > file_temporal_server_api_historyservice_v1_request_response_proto_depIdxs = nil

12003 }

go.temporal.io/server/common/metrics/defs.go 44 covered LOC · 8 ranges

Open complete file

20 )

21

22 > func NewTimerDef(name string, opts ...Option) timerDefinition { defs.go

23 > // This line cannot be combined with others!

24 > // This ensures the stack trace has information of the caller.

25 > def := newMetricDefinition(name, opts...)

26 > globalRegistry.register(def)

27 > return timerDefinition{def}

28 > }

29

30 > func NewBytesHistogramDef(name string, opts ...Option) histogramDefinition { defs.go

31 > // This line cannot be combined with others!

32 > // This ensures the stack trace has information of the caller.

33 > def := newMetricDefinition(name, append(opts, WithUnit(Bytes))...)

34 > globalRegistry.register(def)

35 > return histogramDefinition{def}

36 > }

37

38 > func NewDimensionlessHistogramDef(name string, opts ...Option) histogramDefinition { defs.go

39 > // This line cannot be combined with others!

40 > // This ensures the stack trace has information of the caller.

41 > def := newMetricDefinition(name, append(opts, WithUnit(Dimensionless))...)

42 > globalRegistry.register(def)

43 > return histogramDefinition{def}

44 > }

45

46 > func NewCounterDef(name string, opts ...Option) counterDefinition { defs.go

47 > // This line cannot be combined with others!

48 > // This ensures the stack trace has information of the caller.

49 > def := newMetricDefinition(name, opts...)

50 > globalRegistry.register(def)

51 > return counterDefinition{def}

52 > }

53

54 > func NewGaugeDef(name string, opts ...Option) gaugeDefinition { defs.go

55 > // This line cannot be combined with others!

56 > // This ensures the stack trace has information of the caller.

57 > def := newMetricDefinition(name, opts...)

58 > globalRegistry.register(def)

59 > return gaugeDefinition{def}

60 > }

61

62 func (d histogramDefinition) With(handler Handler) HistogramIface {

64 }

65

66 > func (d counterDefinition) With(handler Handler) CounterIface { defs.go

67 > return handler.Counter(d.name)

68 > }

69

70 > func (d gaugeDefinition) With(handler Handler) GaugeIface { defs.go

71 > return handler.Gauge(d.name)

72 > }

73

74 > func (d timerDefinition) With(handler Handler) TimerIface { defs.go

75 > return handler.Timer(d.name)

76 > }

go.temporal.io/server/api/matchingservice/v1/request_response.pb.go 43 covered LOC · 1 range

Open complete file

6833 }

6834

6835 > func init() { file_temporal_server_api_matchingservice_v1_request_response_proto_init() } request_response.pb.go

6836 > func file_temporal_server_api_matchingservice_v1_request_response_proto_init() {

6837 > if File_temporal_server_api_matchingservice_v1_request_response_proto != nil {

6838 > return

6839 > }

6840 > file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[27].OneofWrappers = []any{

6841 > (*UpdateWorkerBuildIdCompatibilityRequest_ApplyPublicRequest_)(nil),

6842 > (*UpdateWorkerBuildIdCompatibilityRequest_RemoveBuildIds_)(nil),

6843 > (*UpdateWorkerBuildIdCompatibilityRequest_PersistUnknownBuildId)(nil),

6844 > }

6845 > file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[29].OneofWrappers = []any{

6846 > (*GetWorkerVersioningRulesRequest_Request)(nil),

6847 > }

6848 > file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[31].OneofWrappers = []any{

6849 > (*UpdateWorkerVersioningRulesRequest_Request)(nil),

6850 > }

6851 > file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[37].OneofWrappers = []any{

6852 > (*SyncDeploymentUserDataRequest_UpdateVersionData)(nil),

6853 > (*SyncDeploymentUserDataRequest_ForgetVersion)(nil),

6854 > }

6855 > file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes[56].OneofWrappers = []any{

6856 > (*DispatchNexusTaskResponse_HandlerError)(nil),

6857 > (*DispatchNexusTaskResponse_Response)(nil),

6858 > (*DispatchNexusTaskResponse_RequestTimeout)(nil),

6859 > (*DispatchNexusTaskResponse_Failure)(nil),

6860 > }

6861 > type x struct{}

6862 > out := protoimpl.TypeBuilder{

6863 > File: protoimpl.DescBuilder{

6864 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

6865 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_matchingservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_matchingservice_v1_request_response_proto_rawDesc)),

6866 > NumEnums: 0,

6867 > NumMessages: 97,

6868 > NumExtensions: 0,

6869 > NumServices: 0,

6870 > },

6871 > GoTypes: file_temporal_server_api_matchingservice_v1_request_response_proto_goTypes,

6872 > DependencyIndexes: file_temporal_server_api_matchingservice_v1_request_response_proto_depIdxs,

6873 > MessageInfos: file_temporal_server_api_matchingservice_v1_request_response_proto_msgTypes,

6874 > }.Build()

6875 > File_temporal_server_api_matchingservice_v1_request_response_proto = out.File

6876 > file_temporal_server_api_matchingservice_v1_request_response_proto_goTypes = nil

6877 > file_temporal_server_api_matchingservice_v1_request_response_proto_depIdxs = nil

6878 }

go.temporal.io/server/common/searchattribute/sadefs/constants.go 43 covered LOC · 15 ranges

Open complete file

261 }

262

263 > dbCustomSearchAttributeFieldNameRE = func() map[enumspb.IndexedValueType]*regexp.Regexp { constants.go

264 > res := map[enumspb.IndexedValueType]*regexp.Regexp{}

265 > for t := range defaultNumDBCustomSearchAttributes {

266 > res[t] = regexp.MustCompile(fmt.Sprintf(`^%s(0[1-9]|[1-9][0-9])$`, t.String()))

267 > }

268 > return res

269 }()

270 )

271

272 // System returns a clone of the system search attributes map.

273 > func System() map[string]enumspb.IndexedValueType { constants.go

274 > return maps.Clone(system)

275 > }

276

277 // Predefined returns a clone of the predefined search attributes map.

278 > func Predefined() map[string]enumspb.IndexedValueType { constants.go

279 > return maps.Clone(predefined)

280 > }

281

282 // PredefinedWhiteList returns a clone of the predefined whitelist search attributes map.

283 > func PredefinedWhiteList() map[string]enumspb.IndexedValueType { constants.go

284 > return maps.Clone(predefinedWhiteList)

285 > }

286

287 // Reserved returns a clone of the reserved field names map.

291

292 // IsSystem returns true if name is system search attribute

293 > func IsSystem(name string) bool { constants.go

294 > _, ok := system[name]

295 > return ok

296 > }

297

298 // IsReserved returns true if name is system reserved and can't be used as custom search attribute name.

299 > func IsReserved(name string) bool { constants.go

300 > if _, ok := system[name]; ok {

301 return true

302 }

303 > if _, ok := predefined[name]; ok { constants.go

304 return true

305 }

306 > if _, ok := reserved[name]; ok { constants.go

307 return true

308 }

309 > return strings.HasPrefix(name, ReservedPrefix) constants.go

310 }

311

323

324 // IsChasmSystem returns true if name is a system search attribute used by CHASM

325 > func IsChasmSystem(name string) bool { constants.go

326 > _, ok := chasmSystemSearchAttributes[name]

327 > return ok

328 > }

329

330 // IsChasmOverridableSystem returns true if name is a system search attribute whose dedicated

343 // GetSqlDbColName maps system and reserved search attributes to column names for SQL tables.

344 // If the input is not a system or reserved search attribute, then it returns the input.

345 > func GetSqlDbColName(name string) string { constants.go

346 > if fieldName, ok := sqlDbSystemNameToColName[name]; ok {

347 > return fieldName constants.go

348 > }

349 return name

350 }

352 func GetDBIndexSearchAttributes(

353 override map[enumspb.IndexedValueType]int,

354 > ) *persistencespb.IndexSearchAttributes { constants.go

355 > csa := map[string]enumspb.IndexedValueType{}

356 > for saType, defaultNumAttrs := range defaultNumDBCustomSearchAttributes {

357 > numAttrs := defaultNumAttrs

358 > if value, ok := override[saType]; ok {

359 numAttrs = value

360 }

361 > for i := range numAttrs { constants.go

362 > csa[fmt.Sprintf("%s%02d", saType.String(), i+1)] = saType

363 > }

364 }

365 > return &persistencespb.IndexSearchAttributes{ constants.go

366 > CustomSearchAttributes: csa,

367 > }

368 }

369

go.temporal.io/server/chasm/fields_iterator.go 41 covered LOC · 20 ranges

Open complete file

41 //

42 //nolint:revive // cognitive complexity 26 (> max enabled 25)

43 > func fieldsOf(valueV reflect.Value) iter.Seq[fieldInfo] { fields_iterator.go

44 > valueT := valueV.Type()

45 > dataFieldName := ""

46 > return func(yield func(fi fieldInfo) bool) {

47 > for i := 0; i < valueT.Elem().NumField(); i++ {

48 > fieldV := valueV.Elem().Field(i)

49 > fieldT := fieldV.Type()

50 > if fieldT == UnimplementedComponentT {

51 > continue fields_iterator.go

52 }

53

54 > fieldN := fieldName(valueT.Elem().Field(i)) fields_iterator.go

55 > var fieldErr error

56 > fieldK := fieldKindUnspecified

57 > if fieldT.AssignableTo(protoMessageT) {

58 > if dataFieldName != "" { fields_iterator.go

59 fieldErr = serviceerror.NewInternalf("%s.%s: only one data field %s (implements proto.Message) allowed in component", valueT, fieldN, dataFieldName)

60 }

61 > dataFieldName = fieldN fields_iterator.go

62 > fieldK = fieldKindData

63 } else {

64 prefix := genericTypePrefix(fieldT)

90 }

91

92 > if !yield(fieldInfo{val: fieldV, typ: fieldT, name: fieldN, kind: fieldK, err: fieldErr}) { fields_iterator.go

93 return

94 }

95 }

96 // If the data field is not found, generate one more fake field with only an error set.

97 > if dataFieldName == "" { fields_iterator.go

98 yield(fieldInfo{err: serviceerror.NewInternalf("%s: no data field (implements proto.Message) found", valueT)})

99 }

102

103 // unmanagedFieldsOf yields all non-CHASM managed fields of a struct.

104 > func unmanagedFieldsOf(valueT reflect.Type) iter.Seq[fieldInfo] { fields_iterator.go

105 > return func(yield func(fi fieldInfo) bool) {

106 > if valueT.Kind() == reflect.Pointer {

107 > valueT = valueT.Elem() fields_iterator.go

108 > }

109 > for field := range valueT.Fields() { fields_iterator.go

110 > fieldT := field.Type

111 > if fieldT == UnimplementedComponentT {

112 > continue fields_iterator.go

113 }

114

115 // Skip the data field, which is always CHASM-managed.

116 > if fieldT.AssignableTo(protoMessageT) { fields_iterator.go

117 > continue fields_iterator.go

118 }

119

147 }

148

149 > func fieldName(f reflect.StructField) string { fields_iterator.go

150 > if tagName := f.Tag.Get(fieldNameTag); tagName != "" {

151 return tagName

152 }

153 > return f.Name fields_iterator.go

154 }

155

161 // This is used at registration time to validate that archetypes using Visibility

162 // have configured a businessID alias.

163 > func hasVisibilityField(componentT reflect.Type) bool { fields_iterator.go

164 > if componentT.Kind() == reflect.Pointer {

165 > componentT = componentT.Elem() fields_iterator.go

166 > }

167 > if componentT.Kind() != reflect.Struct { fields_iterator.go

168 return false

169 }

170 > for field := range componentT.Fields() { fields_iterator.go

171 > fieldT := field.Type

172 > if fieldT == visibilityFieldT {

173 return true

174 }

175 }

176 > return false fields_iterator.go

177 }

go.temporal.io/server/chasm/registrable_component.go 41 covered LOC · 16 ranges

Open complete file

36 componentType string,

37 opts ...RegistrableComponentOption,

38 > ) *RegistrableComponent { registrable_component.go

39 > rc := &RegistrableComponent{

40 > componentType: componentType,

41 > goType: reflect.TypeFor[C](),

42 > }

43 > for _, opt := range opts {

44 > opt(rc) registrable_component.go

45 > }

46 > return rc registrable_component.go

47 }

48

101 func WithSearchAttributes(

102 searchAttributes ...SearchAttribute,

103 > ) RegistrableComponentOption { registrable_component.go

104 > return func(rc *RegistrableComponent) {

105 > if len(searchAttributes) == 0 {

106 return

107 }

108

109 > if rc.searchAttributesMapper == nil { registrable_component.go

110 > rc.searchAttributesMapper = newVisibilitySearchAttributesMapper() registrable_component.go

111 > }

112

113 > for _, sa := range searchAttributes { registrable_component.go

114 > alias := sa.definition().alias

115 > field := sa.definition().field

116 > valueType := sa.definition().valueType

117 >

118 > // An identity-mapped system search attribute (alias == field, e.g. TaskQueue,

119 > // ExecutionTime) overrides that system column directly, so it is recorded only in

120 > // overriddenSystemFields; queries resolve via the system column.

121 > if field == alias && sadefs.IsSystem(field) {

122 if !sadefs.IsChasmOverridableSystem(field) {

123 //nolint:forbidigo

132 }

133

134 > if sadefs.IsChasmSystem(alias) { registrable_component.go

135 //nolint:forbidigo

136 panic(fmt.Sprintf("registrable component validation error: CHASM search attribute alias %q is a CHASM system search attribute", alias))

137 }

138 > if !sadefs.IsSystem(alias) && sadefs.IsReserved(alias) { registrable_component.go

139 //nolint:forbidigo

140 panic(fmt.Sprintf("registrable component validation error: CHASM search attribute alias %q is a reserved search attribute", alias))

141 }

142

143 > if _, ok := rc.searchAttributesMapper.systemAliasToField[alias]; ok { registrable_component.go

144 //nolint:forbidigo

145 panic(fmt.Sprintf("registrable component validation error: CHASM search attribute alias %q is already defined as a system search attribute alias", alias))

146 }

147 > if _, ok := rc.searchAttributesMapper.aliasToField[alias]; ok { registrable_component.go

148 //nolint:forbidigo

149 panic(fmt.Sprintf("registrable component validation error: search attribute alias %q is already defined", alias))

150 }

151 > if _, ok := rc.searchAttributesMapper.fieldToAlias[field]; ok { registrable_component.go

152 //nolint:forbidigo

153 panic(fmt.Sprintf("registrable component validation error: search attribute field %q is already defined", field))

154 }

155

156 > rc.searchAttributesMapper.aliasToField[alias] = field registrable_component.go

157 > rc.searchAttributesMapper.fieldToAlias[field] = alias

158 > rc.searchAttributesMapper.saTypeMap[field] = valueType

159 }

160 }

184 func (rc *RegistrableComponent) registerToLibrary(

185 library namer,

186 > ) (string, uint32, error) { registrable_component.go

187 > if rc.library != nil {

188 return "", 0, fmt.Errorf("component %s is already registered in library %s", rc.componentType, rc.library.Name())

189 }

190

191 > rc.library = library registrable_component.go

192 > rc.fqn = FullyQualifiedName(rc.library.Name(), rc.componentType)

193 > rc.componentID = GenerateTypeID(rc.fqn)

194 > return rc.fqn, rc.componentID, nil

195 }

196

203 // The generated ID is used to uniquely identify components and tasks within the CHASM framework. The same FQN will

204 // always produce the same ID.

205 > func GenerateTypeID(fqn string) uint32 { registrable_component.go

206 > return farm.Fingerprint32([]byte(fqn))

207 > }

208

209 // hasBusinessIDAlias returns true if the component has a businessID alias configured

go.temporal.io/server/common/locks/priority_semaphore_impl.go 41 covered LOC · 11 ranges

Open complete file

67 // maximum combined weight for concurrent access, capable of handling multiple priority levels.

68 // Most of the logic is taken directly from golang's semaphore.Weighted.

69 > func NewPrioritySemaphore(n int) *PrioritySemaphoreImpl { priority_semaphore_impl.go

70 > waitLists := make([]*list.List, NumPriorities)

71 > for i := range waitLists {

72 > waitLists[i] = list.New()

73 > }

74 > return &PrioritySemaphoreImpl{

75 > size: n,

76 > waitLists: waitLists,

77 > }

78 }

79

81 // are available or ctx is done. On success, returns nil. On failure, returns

82 // ctx.Err() and leaves the semaphore unchanged.

83 > func (s *PrioritySemaphoreImpl) Acquire(ctx context.Context, priority Priority, n int) error { priority_semaphore_impl.go

84 > if priority >= NumPriorities {

85 // nolint:forbidigo

86 panic(fmt.Sprintf("semaphore: invalid priority %v, priority must be less than %v", priority, NumPriorities))

87 }

88

89 > done := ctx.Done() priority_semaphore_impl.go

90 >

91 > s.mu.Lock()

92 > select {

93 case <-done:

94 // ctx becoming done has "happened before" acquiring the semaphore,

98 s.mu.Unlock()

99 return ctx.Err()

100 > default: priority_semaphore_impl.go

101 }

102 // Check if acquisition can proceed without waiting

103 > if s.size-s.cur >= n && s.noWaiters(priority) { priority_semaphore_impl.go

104 > // Since we hold s.mu and haven't synchronized since checking done, if priority_semaphore_impl.go

105 > // ctx becomes done before we return here, it becoming done must have

106 > // "happened concurrently" with this call - it cannot "happen before"

107 > // we return in this branch. So, we're ok to always acquire here.

108 > s.cur += n

109 > s.mu.Unlock()

110 > return nil

111 > }

112

113 if n > s.size {

173 }

174

175 > func (s *PrioritySemaphoreImpl) Release(n int) { priority_semaphore_impl.go

176 > s.mu.Lock()

177 > defer s.mu.Unlock()

178 > s.cur -= n

179 > if s.cur < 0 {

180 s.mu.Unlock()

181 panic("semaphore: released more than held")

182 }

183 > s.notifyWaiters() priority_semaphore_impl.go

184 }

185

186 > func (s *PrioritySemaphoreImpl) notifyWaiters() { priority_semaphore_impl.go

187 > for _, l := range s.waitLists {

188 > for {

189 > next := l.Front()

190 > if next == nil {

191 > break // No more waiters blocked.

192 }

193

219

220 // noWaiters returns if there is no waiter that has priority higher or equal to lowestPriority.

221 > func (s *PrioritySemaphoreImpl) noWaiters(lowestPriority Priority) bool { priority_semaphore_impl.go

222 > for _, l := range s.waitLists[:lowestPriority+1] {

223 > if l.Len() > 0 {

224 return false

225 }

226 }

227 > return true priority_semaphore_impl.go

228 }

go.temporal.io/server/api/history/v1/message.pb.go 40 covered LOC · 10 ranges

Open complete file

92 func (*VersionHistoryItem) ProtoMessage() {}

93

94 > func (x *VersionHistoryItem) ProtoReflect() protoreflect.Message { message.pb.go

95 > mi := &file_temporal_server_api_history_v1_message_proto_msgTypes[1]

96 > if x != nil {

97 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

98 if ms.LoadMessageInfo() == nil {

101 return ms

102 }

103 > return mi.MessageOf(x) message.pb.go

104 }

105

145 func (*VersionHistory) ProtoMessage() {}

146

147 > func (x *VersionHistory) ProtoReflect() protoreflect.Message { message.pb.go

148 > mi := &file_temporal_server_api_history_v1_message_proto_msgTypes[2]

149 > if x != nil {

150 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

151 if ms.LoadMessageInfo() == nil {

154 return ms

155 }

156 > return mi.MessageOf(x) message.pb.go

157 }

158

162 }

163

164 > func (x *VersionHistory) GetBranchToken() []byte { message.pb.go

165 > if x != nil {

166 > return x.BranchToken

167 > }

168 return nil

169 }

198 func (*VersionHistories) ProtoMessage() {}

199

200 > func (x *VersionHistories) ProtoReflect() protoreflect.Message { message.pb.go

201 > mi := &file_temporal_server_api_history_v1_message_proto_msgTypes[3]

202 > if x != nil {

203 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

204 if ms.LoadMessageInfo() == nil {

207 return ms

208 }

209 > return mi.MessageOf(x) message.pb.go

210 }

211

215 }

216

217 > func (x *VersionHistories) GetCurrentVersionHistoryIndex() int32 { message.pb.go

218 > if x != nil {

219 > return x.CurrentVersionHistoryIndex

220 > }

221 return 0

222 }

498 }

499

500 > func init() { file_temporal_server_api_history_v1_message_proto_init() } message.pb.go

501 > func file_temporal_server_api_history_v1_message_proto_init() {

502 > if File_temporal_server_api_history_v1_message_proto != nil {

503 return

504 }

505 > type x struct{} message.pb.go

506 > out := protoimpl.TypeBuilder{

507 > File: protoimpl.DescBuilder{

508 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

509 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_history_v1_message_proto_rawDesc), len(file_temporal_server_api_history_v1_message_proto_rawDesc)),

510 > NumEnums: 0,

511 > NumMessages: 8,

512 > NumExtensions: 0,

513 > NumServices: 0,

514 > },

515 > GoTypes: file_temporal_server_api_history_v1_message_proto_goTypes,

516 > DependencyIndexes: file_temporal_server_api_history_v1_message_proto_depIdxs,

517 > MessageInfos: file_temporal_server_api_history_v1_message_proto_msgTypes,

518 > }.Build()

519 > File_temporal_server_api_history_v1_message_proto = out.File

520 > file_temporal_server_api_history_v1_message_proto_goTypes = nil

521 > file_temporal_server_api_history_v1_message_proto_depIdxs = nil

522 }

go.temporal.io/server/common/backoff/retrypolicy.go 38 covered LOC · 7 ranges

Open complete file

80

81 // NewExponentialRetryPolicy returns an instance of ExponentialRetryPolicy using the provided initialInterval

82 > func NewExponentialRetryPolicy(initialInterval time.Duration) *ExponentialRetryPolicy { retrypolicy.go

83 > p := &ExponentialRetryPolicy{

84 > initialInterval: initialInterval,

85 > backoffCoefficient: defaultBackoffCoefficient,

86 > maximumInterval: defaultMaximumInterval,

87 > expirationInterval: defaultExpirationInterval,

88 > maximumAttempts: defaultMaximumAttempts,

89 > }

90 >

91 > return p

92 > }

93

94 // NewRetrier is used for creating a new instance of Retrier

113 // All retries are computed using the following formula:

114 // initialInterval * math.Pow(backoffCoefficient, currentAttempt)

115 > func (p *ExponentialRetryPolicy) WithBackoffCoefficient(backoffCoefficient float64) *ExponentialRetryPolicy { retrypolicy.go

116 > p.backoffCoefficient = backoffCoefficient

117 > return p

118 > }

119

120 // WithMaximumInterval sets the maximum interval for each retry.

121 // This does *not* cause the policy to stop retrying when the interval between retries reaches the supplied duration.

122 // That is what WithExpirationInterval does. Instead, this prevents the interval from exceeding maximumInterval.

123 > func (p *ExponentialRetryPolicy) WithMaximumInterval(maximumInterval time.Duration) *ExponentialRetryPolicy { retrypolicy.go

124 > p.maximumInterval = maximumInterval

125 > return p

126 > }

127

128 // WithExpirationInterval sets the absolute expiration interval for all retries

129 > func (p *ExponentialRetryPolicy) WithExpirationInterval(expirationInterval time.Duration) *ExponentialRetryPolicy { retrypolicy.go

130 > p.expirationInterval = expirationInterval

131 > return p

132 > }

133

134 // WithMaximumAttempts sets the maximum number of retry attempts

135 > func (p *ExponentialRetryPolicy) WithMaximumAttempts(maximumAttempts int) *ExponentialRetryPolicy { retrypolicy.go

136 > p.maximumAttempts = maximumAttempts

137 > return p

138 > }

139

140 // ComputeNextDelay returns the next delay interval. This is used by Retrier to delay calling the operation again

267 var _ RetryPolicy = (*ConstantDelayRetryPolicy)(nil)

268

269 > func NewConstantDelayRetryPolicy(delay time.Duration) *ConstantDelayRetryPolicy { retrypolicy.go

270 > return &ConstantDelayRetryPolicy{

271 > maximumAttempts: defaultMaximumAttempts,

272 > jitterPct: defaultJitterPct,

273 > delay: delay,

274 > }

275 > }

276

277 > func (p *ConstantDelayRetryPolicy) WithMaximumAttempts(maximumAttempts int) *ConstantDelayRetryPolicy { retrypolicy.go

278 > p.maximumAttempts = maximumAttempts

279 > return p

280 > }

281

282 func (p *ConstantDelayRetryPolicy) WithJitter(jitterPct float64) *ConstantDelayRetryPolicy {

go.temporal.io/server/common/namespace/namespace.go 38 covered LOC · 13 ranges

Open complete file

81 resolver ReplicationResolver,

82 mutations ...Mutation,

83 > ) (*Namespace, error) { namespace.go

84 > if resolver == nil {

85 return nil, serviceerror.NewInvalidArgument("replicationResolver must be provided")

86 }

87 > ns := &Namespace{ namespace.go

88 > info: detail.Info,

89 > config: detail.Config,

90 > configVersion: detail.ConfigVersion,

91 > customSearchAttributesMapper: CustomSearchAttributesMapper{

92 > fieldToAlias: detail.Config.CustomSearchAttributeAliases,

93 > aliasToField: util.InverseMap(detail.Config.CustomSearchAttributeAliases),

94 > },

95 > replicationResolver: resolver,

96 > }

97 >

98 > for _, m := range mutations {

99 > m.apply(ns) namespace.go

100 > }

101

102 > return ns, nil namespace.go

103 }

104

159

160 // ID observes this namespace's permanent unique identifier in string form.

161 > func (ns *Namespace) ID() ID { namespace.go

162 > if ns.info == nil {

163 return ID("")

164 }

165 > return ID(ns.info.Id) namespace.go

166 }

167

168 // Name observes this namespace's configured name.

169 > func (ns *Namespace) Name() Name { namespace.go

170 > if ns.info == nil {

171 return Name("")

172 }

173 > return Name(ns.info.Name) namespace.go

174 }

175

197 // ClusterNames observes the names of the clusters to which this namespace is

198 // replicated.

199 > func (ns *Namespace) ClusterNames(businessID string) []string { namespace.go

200 > return ns.replicationResolver.ClusterNames(businessID)

201 > }

202

203 // IsOnCluster returns true is namespace is registered on cluster otherwise false.

212

213 // FailoverVersion return the namespace failover version

214 > func (ns *Namespace) FailoverVersion(businessID string) int64 { namespace.go

215 > return ns.replicationResolver.FailoverVersion(businessID)

216 > }

217

218 // IsGlobalNamespace returns whether the namespace is a global namespace.

219 // Being a global namespace doesn't necessarily mean that there are multiple registered clusters for it, only that it

220 // has a failover version. To determine whether operations should be replicated for a namespace, see ReplicationPolicy.

221 > func (ns *Namespace) IsGlobalNamespace() bool { namespace.go

222 > return ns.replicationResolver.IsGlobalNamespace()

223 > }

224

225 // FailoverNotificationVersion return the global notification version of when failover happened

337 }

338

339 > func (id ID) String() string { namespace.go

340 > return string(id)

341 > }

342

343 func (id ID) IsEmpty() bool {

345 }

346

347 > func (n Name) String() string { namespace.go

348 > return string(n)

349 > }

350

351 func (n Name) IsEmpty() bool {

go.temporal.io/server/service/history/workflow/timer_sequence.go 37 covered LOC · 10 ranges

Open complete file

61 func NewTimerSequence(

62 mutableState historyi.MutableState,

63 > ) *timerSequenceImpl { timer_sequence.go

64 > return &timerSequenceImpl{

65 > mutableState: mutableState,

66 > }

67 > }

68

69 > func (t *timerSequenceImpl) CreateNextUserTimer() (bool, error) { timer_sequence.go

70 >

71 > sequenceIDs := t.LoadAndSortUserTimers()

72 > if len(sequenceIDs) == 0 {

73 > return false, nil timer_sequence.go

74 > }

75

76 firstTimerTask := sequenceIDs[0]

107 }

108

109 > func (t *timerSequenceImpl) CreateNextActivityTimer() (bool, error) { timer_sequence.go

110 >

111 > sequenceIDs := t.LoadAndSortActivityTimers()

112 > if len(sequenceIDs) == 0 {

113 > return false, nil timer_sequence.go

114 > }

115

116 firstTimerTask := sequenceIDs[0]

156 }

157

158 > func (t *timerSequenceImpl) LoadAndSortUserTimers() []TimerSequenceID { timer_sequence.go

159 >

160 > pendingTimers := t.mutableState.GetPendingTimerInfos()

161 > timers := make(TimerSequenceIDs, 0, len(pendingTimers))

162 >

163 > for _, timerInfo := range pendingTimers {

164

165 if sequenceID := t.getUserTimerTimeout(

170 }

171

172 > sort.Sort(timers) timer_sequence.go

173 > return timers

174 }

175

176 > func (t *timerSequenceImpl) LoadAndSortActivityTimers() []TimerSequenceID { timer_sequence.go

177 > // there can be 4 timer per activity

178 > // see TimerType

179 > pendingActivities := t.mutableState.GetPendingActivityInfos()

180 > activityTimers := make(TimerSequenceIDs, 0, len(pendingActivities)*4)

181 >

182 > for _, activityInfo := range pendingActivities {

183 // skip activities that are paused

184 if activityInfo.Paused {

210 }

211

212 > sort.Sort(activityTimers) timer_sequence.go

213 > return activityTimers

214 }

215

381

382 // Len implements sort.Interface

383 > func (s TimerSequenceIDs) Len() int { timer_sequence.go

384 > return len(s)

385 > }

386

387 // Swap implements sort.Interface.

go.temporal.io/server/api/adminservice/v1/request_response.pb.go 36 covered LOC · 1 range

Open complete file

6623 }

6624

6625 > func init() { file_temporal_server_api_adminservice_v1_request_response_proto_init() } request_response.pb.go

6626 > func file_temporal_server_api_adminservice_v1_request_response_proto_init() {

6627 > if File_temporal_server_api_adminservice_v1_request_response_proto != nil {

6628 > return

6629 > }

6630 > file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[59].OneofWrappers = []any{

6631 > (*StreamWorkflowReplicationMessagesRequest_SyncReplicationState)(nil),

6632 > }

6633 > file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[60].OneofWrappers = []any{

6634 > (*StreamWorkflowReplicationMessagesResponse_Messages)(nil),

6635 > }

6636 > file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[61].OneofWrappers = []any{

6637 > (*GetNamespaceRequest_Namespace)(nil),

6638 > (*GetNamespaceRequest_Id)(nil),

6639 > }

6640 > file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[90].OneofWrappers = []any{

6641 > (*StartAdminBatchOperationRequest_RefreshTasksOperation)(nil),

6642 > }

6643 > type x struct{}

6644 > out := protoimpl.TypeBuilder{

6645 > File: protoimpl.DescBuilder{

6646 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

6647 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_adminservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_adminservice_v1_request_response_proto_rawDesc)),

6648 > NumEnums: 1,

6649 > NumMessages: 105,

6650 > NumExtensions: 0,

6651 > NumServices: 0,

6652 > },

6653 > GoTypes: file_temporal_server_api_adminservice_v1_request_response_proto_goTypes,

6654 > DependencyIndexes: file_temporal_server_api_adminservice_v1_request_response_proto_depIdxs,

6655 > EnumInfos: file_temporal_server_api_adminservice_v1_request_response_proto_enumTypes,

6656 > MessageInfos: file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes,

6657 > }.Build()

6658 > File_temporal_server_api_adminservice_v1_request_response_proto = out.File

6659 > file_temporal_server_api_adminservice_v1_request_response_proto_goTypes = nil

6660 > file_temporal_server_api_adminservice_v1_request_response_proto_depIdxs = nil

6661 }

go.temporal.io/server/api/replication/v1/message.pb.go 36 covered LOC · 2 ranges

Open complete file

2441 }

2442

2443 > func init() { file_temporal_server_api_replication_v1_message_proto_init() } message.pb.go

2444 > func file_temporal_server_api_replication_v1_message_proto_init() {

2445 > if File_temporal_server_api_replication_v1_message_proto != nil {

2446 return

2447 }

2448 > file_temporal_server_api_replication_v1_message_proto_msgTypes[0].OneofWrappers = []any{ message.pb.go

2449 > (*ReplicationTask_NamespaceTaskAttributes)(nil),

2450 > (*ReplicationTask_SyncShardStatusTaskAttributes)(nil),

2451 > (*ReplicationTask_SyncActivityTaskAttributes)(nil),

2452 > (*ReplicationTask_HistoryTaskAttributes)(nil),

2453 > (*ReplicationTask_SyncWorkflowStateTaskAttributes)(nil),

2454 > (*ReplicationTask_TaskQueueUserDataAttributes)(nil),

2455 > (*ReplicationTask_SyncHsmAttributes)(nil),

2456 > (*ReplicationTask_BackfillHistoryTaskAttributes)(nil),

2457 > (*ReplicationTask_VerifyVersionedTransitionTaskAttributes)(nil),

2458 > (*ReplicationTask_SyncVersionedTransitionTaskAttributes)(nil),

2459 > }

2460 > file_temporal_server_api_replication_v1_message_proto_msgTypes[21].OneofWrappers = []any{

2461 > (*VersionedTransitionArtifact_SyncWorkflowStateMutationAttributes)(nil),

2462 > (*VersionedTransitionArtifact_SyncWorkflowStateSnapshotAttributes)(nil),

2463 > }

2464 > type x struct{}

2465 > out := protoimpl.TypeBuilder{

2466 > File: protoimpl.DescBuilder{

2467 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

2468 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_replication_v1_message_proto_rawDesc), len(file_temporal_server_api_replication_v1_message_proto_rawDesc)),

2469 > NumEnums: 0,

2470 > NumMessages: 23,

2471 > NumExtensions: 0,

2472 > NumServices: 0,

2473 > },

2474 > GoTypes: file_temporal_server_api_replication_v1_message_proto_goTypes,

2475 > DependencyIndexes: file_temporal_server_api_replication_v1_message_proto_depIdxs,

2476 > MessageInfos: file_temporal_server_api_replication_v1_message_proto_msgTypes,

2477 > }.Build()

2478 > File_temporal_server_api_replication_v1_message_proto = out.File

2479 > file_temporal_server_api_replication_v1_message_proto_goTypes = nil

2480 > file_temporal_server_api_replication_v1_message_proto_depIdxs = nil

2481 }

go.temporal.io/server/common/namespace/testconstructors.go 36 covered LOC · 8 ranges

Open complete file

13 config *persistencespb.NamespaceConfig,

14 targetCluster string,

15 > ) *Namespace { testconstructors.go

16 > detail := &persistencespb.NamespaceDetail{

17 > Info: ensureInfo(info),

18 > Config: ensureConfig(config),

19 > ReplicationConfig: &persistencespb.NamespaceReplicationConfig{

20 > ActiveClusterName: targetCluster,

21 > Clusters: []string{targetCluster},

22 > },

23 > FailoverVersion: common.EmptyVersion,

24 > }

25 > factory := NewDefaultReplicationResolverFactory()

26 > resolver := factory(detail)

27 > ns, _ := FromPersistentState(detail, resolver, WithGlobalFlag(false))

28 > return ns

29 > }

30

31 // NewNamespaceForTest returns an entry with test data

55 repConfig *persistencespb.NamespaceReplicationConfig,

56 failoverVersion int64,

57 > ) *Namespace { testconstructors.go

58 > detail := &persistencespb.NamespaceDetail{

59 > Info: ensureInfo(info),

60 > Config: ensureConfig(config),

61 > ReplicationConfig: ensureRepConfig(repConfig),

62 > FailoverVersion: failoverVersion,

63 > }

64 > factory := NewDefaultReplicationResolverFactory()

65 > resolver := factory(detail)

66 > ns, _ := FromPersistentState(detail, resolver, WithGlobalFlag(true))

67 > return ns

68 > }

69

70 > func ensureInfo(proto *persistencespb.NamespaceInfo) *persistencespb.NamespaceInfo { testconstructors.go

71 > if proto == nil {

72 return &persistencespb.NamespaceInfo{}

73 }

74 > return proto testconstructors.go

75 }

76

77 > func ensureConfig(proto *persistencespb.NamespaceConfig) *persistencespb.NamespaceConfig { testconstructors.go

78 > if proto == nil {

79 return &persistencespb.NamespaceConfig{}

80 }

81 > return proto testconstructors.go

82 }

83

84 > func ensureRepConfig(proto *persistencespb.NamespaceReplicationConfig) *persistencespb.NamespaceReplicationConfig { testconstructors.go

85 > if proto == nil {

86 return &persistencespb.NamespaceReplicationConfig{}

87 }

88 > return proto testconstructors.go

89 }

go.temporal.io/server/common/util.go 36 covered LOC · 7 ranges

Open complete file

161

162 // CreatePersistenceClientRetryPolicy creates a retry policy for calls to persistence

163 > func CreatePersistenceClientRetryPolicy() backoff.RetryPolicy { util.go

164 > return backoff.NewExponentialRetryPolicy(persistenceClientRetryInitialInterval).

165 > WithMaximumAttempts(persistenceClientRetryMaxAttempts)

166 > }

167

168 // CreateFrontendClientRetryPolicy creates a retry policy for calls to frontend service

249

250 // CreateTaskReschedulePolicy creates a retry policy for rescheduling task with errors not equal to ErrTaskRetry

251 > func CreateTaskReschedulePolicy() backoff.RetryPolicy { util.go

252 > return backoff.NewExponentialRetryPolicy(taskRescheduleInitialInterval).

253 > WithBackoffCoefficient(taskRescheduleBackoffCoefficient).

254 > WithMaximumInterval(taskRescheduleMaxInterval).

255 > WithExpirationInterval(backoff.NoInterval)

256 > }

257

258 // CreateDependencyTaskNotCompletedReschedulePolicy creates a retry policy for rescheduling task with

259 // ErrDependencyTaskNotCompleted

260 > func CreateDependencyTaskNotCompletedReschedulePolicy() backoff.RetryPolicy { util.go

261 > return backoff.NewExponentialRetryPolicy(dependencyTaskNotCompletedRescheduleInitialInterval).

262 > WithBackoffCoefficient(dependencyTaskNotCompletedRescheduleBackoffCoefficient).

263 > WithMaximumInterval(dependencyTaskNotCompletedRescheduleMaxInterval).

264 > WithExpirationInterval(backoff.NoInterval)

265 > }

266

267 // CreateTaskNotReadyReschedulePolicy creates a retry policy for rescheduling task with ErrTaskRetry

268 > func CreateTaskNotReadyReschedulePolicy() backoff.RetryPolicy { util.go

269 > return backoff.NewExponentialRetryPolicy(taskNotReadyRescheduleInitialInterval).

270 > WithBackoffCoefficient(taskNotReadyRescheduleBackoffCoefficient).

271 > WithMaximumInterval(taskNotReadyRescheduleMaxInterval).

272 > WithExpirationInterval(backoff.NoInterval)

273 > }

274

275 // CreateTaskResourceExhaustedReschedulePolicy creates a retry policy for rescheduling task with resource exhausted error

276 > func CreateTaskResourceExhaustedReschedulePolicy() backoff.RetryPolicy { util.go

277 > return backoff.NewExponentialRetryPolicy(taskResourceExhaustedRescheduleInitialInterval).

278 > WithBackoffCoefficient(taskResourceExhaustedRescheduleBackoffCoefficient).

279 > WithMaximumInterval(taskResourceExhaustedRescheduleMaxInterval).

280 > WithExpirationInterval(backoff.NoInterval)

281 > }

282

283 // CreateSdkClientFactoryRetryPolicy creates a retry policy to handle SdkClientFactory NewClient when frontend service is not ready

420 workflowID string,

421 numberOfShards int32,

422 > ) int32 { util.go

423 > idBytes := []byte(namespaceID + "_" + workflowID)

424 > hash := farm.Fingerprint32(idBytes)

425 > return int32(hash%uint32(numberOfShards)) + 1 // ShardID starts with 1

426 > }

427

428 func MapShardID(

688

689 // CloneProto is a generic typed version of proto.Clone from proto.

690 > func CloneProto[T proto.Message](v T) T { util.go

691 > return proto.Clone(v).(T)

692 > }

693

694 func CloneProtoMap[K comparable, T proto.Message](src map[K]T) map[K]T {

go.temporal.io/server/api/persistence/v1/update.pb.go 35 covered LOC · 3 ranges

Open complete file

222 func (*UpdateInfo) ProtoMessage() {}

223

224 > func (x *UpdateInfo) ProtoReflect() protoreflect.Message { update.pb.go

225 > mi := &file_temporal_server_api_persistence_v1_update_proto_msgTypes[3]

226 > if x != nil {

227 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

228 if ms.LoadMessageInfo() == nil {

231 return ms

232 }

233 > return mi.MessageOf(x) update.pb.go

234 }

235

422 }

423

424 > func init() { file_temporal_server_api_persistence_v1_update_proto_init() } update.pb.go

425 > func file_temporal_server_api_persistence_v1_update_proto_init() {

426 > if File_temporal_server_api_persistence_v1_update_proto != nil {

427 > return

428 > }

429 > file_temporal_server_api_persistence_v1_hsm_proto_init()

430 > file_temporal_server_api_persistence_v1_update_proto_msgTypes[0].OneofWrappers = []any{

431 > (*UpdateAdmissionInfo_HistoryPointer_)(nil),

432 > }

433 > file_temporal_server_api_persistence_v1_update_proto_msgTypes[3].OneofWrappers = []any{

434 > (*UpdateInfo_Acceptance)(nil),

435 > (*UpdateInfo_Completion)(nil),

436 > (*UpdateInfo_Admission)(nil),

437 > }

438 > type x struct{}

439 > out := protoimpl.TypeBuilder{

440 > File: protoimpl.DescBuilder{

441 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

442 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_update_proto_rawDesc), len(file_temporal_server_api_persistence_v1_update_proto_rawDesc)),

443 > NumEnums: 0,

444 > NumMessages: 5,

445 > NumExtensions: 0,

446 > NumServices: 0,

447 > },

448 > GoTypes: file_temporal_server_api_persistence_v1_update_proto_goTypes,

449 > DependencyIndexes: file_temporal_server_api_persistence_v1_update_proto_depIdxs,

450 > MessageInfos: file_temporal_server_api_persistence_v1_update_proto_msgTypes,

451 > }.Build()

452 > File_temporal_server_api_persistence_v1_update_proto = out.File

453 > file_temporal_server_api_persistence_v1_update_proto_goTypes = nil

454 > file_temporal_server_api_persistence_v1_update_proto_depIdxs = nil

455 }

go.temporal.io/server/common/dynamicconfig/deepcopy.go 31 covered LOC · 6 ranges

Open complete file

9 // deepCopyForMapstructure does a simple deep copy of T. Fancy cases (anything other than plain old data)

10 // is not handled and will panic.

11 > func deepCopyForMapstructure[T any](t T) T { deepcopy.go

12 > // nolint:revive // this will be triggered from a static initializer before it can be triggered from production code

13 > return deepCopyValue(reflect.ValueOf(t)).Interface().(T)

14 > }

15

16 > func deepCopyValue(v reflect.Value) reflect.Value { deepcopy.go

17 > switch v.Kind() {

18 case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,

19 reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,

20 > reflect.Uintptr, reflect.Float32, reflect.Float64, reflect.String: deepcopy.go

21 > nv := reflect.New(v.Type()).Elem()

22 > nv.Set(v)

23 > return nv

24 case reflect.Array:

25 nv := reflect.New(v.Type()).Elem()

42 }

43 return deepCopyValue(v.Elem()).Addr()

44 > case reflect.Slice: deepcopy.go

45 > if v.IsNil() {

46 > return v

47 > }

48 nv := reflect.MakeSlice(v.Type(), v.Len(), v.Len())

49 for i := range v.Len() {

51 }

52 return nv

53 > case reflect.Struct: deepcopy.go

54 > // Special case for time.Time: it has unexported fields so we can't copy it field by

55 > // field, but we can copy zero values (which is all we need for default values).

56 > if v.Type() == reflect.TypeFor[time.Time]() {

57 > if v.Interface().(time.Time).IsZero() {

58 > return reflect.ValueOf(time.Time{})

59 > }

60 // nolint:forbidigo // this will be triggered from a static initializer before it can be triggered from production code

61 panic(fmt.Sprintf("Can't deep copy non-zero time.Time: %v", v.Interface()))

62 }

63 > nv := reflect.New(v.Type()).Elem() deepcopy.go

64 > for i := range v.Type().NumField() {

65 > nv.Field(i).Set(deepCopyValue(v.Field(i)))

66 > }

67 > return nv

68 > case reflect.Interface, reflect.Func, reflect.Chan:

69 > // only nil values of any other reference types allowed!

70 > if v.IsNil() {

71 > return v

72 > }

73 fallthrough

74 default:

go.temporal.io/server/api/enums/v1/task.pb.go 30 covered LOC · 6 ranges

Open complete file

217 }

218

219 > func (x TaskType) String() string { task.pb.go

220 > switch x {

221 case TASK_TYPE_UNSPECIFIED:

222 return "Unspecified"

285

286 // Deprecated: Use TaskPriority.Descriptor instead.

287 > case TASK_TYPE_REPLICATION_SYNC_VERSIONED_TRANSITION: task.pb.go

288 > return "ReplicationSyncVersionedTransition"

289 case TASK_TYPE_CHASM_PURE:

290 return "ChasmPure"

303 }

304

305 > func (TaskType) Descriptor() protoreflect.EnumDescriptor { task.pb.go

306 > return file_temporal_server_api_enums_v1_task_proto_enumTypes[1].Descriptor()

307 > }

308

309 func (TaskType) Type() protoreflect.EnumType {

361 }

362

363 > func (TaskPriority) Descriptor() protoreflect.EnumDescriptor { task.pb.go

364 > return file_temporal_server_api_enums_v1_task_proto_enumTypes[2].Descriptor()

365 > }

366

367 func (TaskPriority) Type() protoreflect.EnumType {

456 }

457

458 > func init() { file_temporal_server_api_enums_v1_task_proto_init() } task.pb.go

459 > func file_temporal_server_api_enums_v1_task_proto_init() {

460 > if File_temporal_server_api_enums_v1_task_proto != nil {

461 return

462 }

463 > type x struct{} task.pb.go

464 > out := protoimpl.TypeBuilder{

465 > File: protoimpl.DescBuilder{

466 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

467 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_task_proto_rawDesc), len(file_temporal_server_api_enums_v1_task_proto_rawDesc)),

468 > NumEnums: 3,

469 > NumMessages: 0,

470 > NumExtensions: 0,

471 > NumServices: 0,

472 > },

473 > GoTypes: file_temporal_server_api_enums_v1_task_proto_goTypes,

474 > DependencyIndexes: file_temporal_server_api_enums_v1_task_proto_depIdxs,

475 > EnumInfos: file_temporal_server_api_enums_v1_task_proto_enumTypes,

476 > }.Build()

477 > File_temporal_server_api_enums_v1_task_proto = out.File

478 > file_temporal_server_api_enums_v1_task_proto_goTypes = nil

479 > file_temporal_server_api_enums_v1_task_proto_depIdxs = nil

480 }

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/execution_maps.go 30 covered LOC · 5 ranges

Open complete file

53 )

54

55 > func stringMap(a []string, f func(string) string) []string { execution_maps.go

56 > b := make([]string, len(a))

57 > for i, v := range a {

58 > b[i] = f(v)

59 > }

60 > return b

61 }

62

63 > func makeDeleteMapQry(tableName string) string { execution_maps.go

64 > return fmt.Sprintf(deleteMapQryTemplate, tableName)

65 > }

66

67 > func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string { execution_maps.go

68 > return fmt.Sprintf(setKeyInMapQryTemplate,

69 > tableName,

70 > strings.Join(nonPrimaryKeyColumns, ","),

71 > strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {

72 > return ":" + x

73 > }), ","),

74 > strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {

75 > return x + "=VALUES(" + x + ")"

76 > }), ","),

77 mapKeyName)

78 }

79

80 > func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string { execution_maps.go

81 > return fmt.Sprintf(deleteKeyInMapQryTemplate,

82 > tableName,

83 > mapKeyName)

84 > }

85

86 > func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string { execution_maps.go

87 > return fmt.Sprintf(getMapQryTemplate,

88 > tableName,

89 > mapKeyName,

90 > strings.Join(nonPrimaryKeyColumns, ","))

91 > }

92

93 var (

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/execution_maps.go 30 covered LOC · 6 ranges

Open complete file

86 )

87

88 > func stringMap(a []string, f func(string) string) []string { execution_maps.go

89 > b := make([]string, len(a))

90 > for i, v := range a {

91 > b[i] = f(v)

92 > }

93 > return b

94 }

95

96 > func makeDeleteMapQry(tableName string) string { execution_maps.go

97 > return fmt.Sprintf(deleteMapQueryTemplate, tableName)

98 > }

99

100 > func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string { execution_maps.go

101 > return fmt.Sprintf(setKeyInMapQueryTemplate,

102 > tableName,

103 > strings.Join(nonPrimaryKeyColumns, ","),

104 > strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {

105 > return ":" + x

106 > }), ","),

107 mapKeyName,

108 > strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string { execution_maps.go

109 > return "excluded." + x

110 > }), ","))

111 }

112

113 > func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string { execution_maps.go

114 > return fmt.Sprintf(deleteKeyInMapQueryTemplate,

115 > tableName,

116 > mapKeyName)

117 > }

118

119 > func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string { execution_maps.go

120 > return fmt.Sprintf(getMapQueryTemplate,

121 > tableName,

122 > mapKeyName,

123 > strings.Join(nonPrimaryKeyColumns, ","))

124 > }

125

126 var (

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/execution_maps.go 30 covered LOC · 5 ranges

Open complete file

52 )

53

54 > func stringMap(a []string, f func(string) string) []string { execution_maps.go

55 > b := make([]string, len(a))

56 > for i, v := range a {

57 > b[i] = f(v)

58 > }

59 > return b

60 }

61

62 > func makeDeleteMapQry(tableName string) string { execution_maps.go

63 > return fmt.Sprintf(deleteMapQryTemplate, tableName)

64 > }

65

66 > func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string { execution_maps.go

67 > return fmt.Sprintf(setKeyInMapQryTemplate,

68 > tableName,

69 > strings.Join(nonPrimaryKeyColumns, ","),

70 > strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {

71 > return ":" + x

72 > }), ","),

73 > strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {

74 > return x + "=" + x

75 > }), ","),

76 mapKeyName)

77 }

78

79 > func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string { execution_maps.go

80 > return fmt.Sprintf(deleteKeyInMapQryTemplate,

81 > tableName,

82 > mapKeyName)

83 > }

84

85 > func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string { execution_maps.go

86 > return fmt.Sprintf(getMapQryTemplate,

87 > tableName,

88 > mapKeyName,

89 > strings.Join(nonPrimaryKeyColumns, ","))

90 > }

91

92 var (

go.temporal.io/server/service/history/historybuilder/history_builder.go 30 covered LOC · 2 ranges

Open complete file

66 metricsHandler metrics.Handler,

67 maxEventBatchSizeInBytes dynamicconfig.IntPropertyFn,

68 > ) *HistoryBuilder { history_builder.go

69 > return &HistoryBuilder{

70 > EventStore: EventStore{

71 > state: HistoryBuilderStateMutable,

72 > timeSource: timeSource,

73 > taskIDGenerator: taskIDGenerator,

74 >

75 > version: version,

76 > nextEventID: nextEventID,

77 >

78 > workflowFinished: false,

79 >

80 > dbBufferBatch: dbBufferBatch,

81 > dbClearBuffer: false,

82 > memEventsBatches: nil,

83 > memLatestBatch: nil,

84 > memBufferBatch: nil,

85 > scheduledIDToStartedID: make(map[int64]int64),

86 > requestIDToEventID: make(map[string]int64),

87 >

88 > maxEventBatchSizeInBytes: maxEventBatchSizeInBytes,

89 >

90 > metricsHandler: metricsHandler,

91 > },

92 > EventFactory: EventFactory{timeSource: timeSource, version: version},

93 > }

94 > }

95

96 func (b *HistoryBuilder) SetTimeSource(timeSource clock.TimeSource) {

153 }

154

155 > func (b *HistoryBuilder) IsDirty() bool { history_builder.go

156 > return b.EventStore.IsDirty()

157 > }

158

159 // AddWorkflowExecutionStartedEvent

go.temporal.io/server/api/taskqueue/v1/message.pb.go 29 covered LOC · 2 ranges

Open complete file

1330 }

1331

1332 > func init() { file_temporal_server_api_taskqueue_v1_message_proto_init() } message.pb.go

1333 > func file_temporal_server_api_taskqueue_v1_message_proto_init() {

1334 > if File_temporal_server_api_taskqueue_v1_message_proto != nil {

1335 return

1336 }

1337 > file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0].OneofWrappers = []any{ message.pb.go

1338 > (*TaskVersionDirective_UseAssignmentRules)(nil),

1339 > (*TaskVersionDirective_AssignedBuildId)(nil),

1340 > }

1341 > file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5].OneofWrappers = []any{

1342 > (*TaskQueuePartition_NormalPartitionId)(nil),

1343 > (*TaskQueuePartition_StickyName)(nil),

1344 > (*TaskQueuePartition_WorkerCommands)(nil),

1345 > }

1346 > type x struct{}

1347 > out := protoimpl.TypeBuilder{

1348 > File: protoimpl.DescBuilder{

1349 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

1350 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc), len(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc)),

1351 > NumEnums: 0,

1352 > NumMessages: 16,

1353 > NumExtensions: 0,

1354 > NumServices: 0,

1355 > },

1356 > GoTypes: file_temporal_server_api_taskqueue_v1_message_proto_goTypes,

1357 > DependencyIndexes: file_temporal_server_api_taskqueue_v1_message_proto_depIdxs,

1358 > MessageInfos: file_temporal_server_api_taskqueue_v1_message_proto_msgTypes,

1359 > }.Build()

1360 > File_temporal_server_api_taskqueue_v1_message_proto = out.File

1361 > file_temporal_server_api_taskqueue_v1_message_proto_goTypes = nil

1362 > file_temporal_server_api_taskqueue_v1_message_proto_depIdxs = nil

1363 }

go.temporal.io/server/api/clock/v1/message.pb.go 28 covered LOC · 5 ranges

Open complete file

45 func (*VectorClock) ProtoMessage() {}

46

47 > func (x *VectorClock) ProtoReflect() protoreflect.Message { message.pb.go

48 > mi := &file_temporal_server_api_clock_v1_message_proto_msgTypes[0]

49 > if x != nil {

50 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

51 if ms.LoadMessageInfo() == nil {

54 return ms

55 }

56 > return mi.MessageOf(x) message.pb.go

57 }

58

69 }

70

71 > func (x *VectorClock) GetClock() int64 { message.pb.go

72 > if x != nil {

73 > return x.Clock

74 > }

75 return 0

76 }

193 }

194

195 > func init() { file_temporal_server_api_clock_v1_message_proto_init() } message.pb.go

196 > func file_temporal_server_api_clock_v1_message_proto_init() {

197 > if File_temporal_server_api_clock_v1_message_proto != nil {

198 return

199 }

200 > type x struct{} message.pb.go

201 > out := protoimpl.TypeBuilder{

202 > File: protoimpl.DescBuilder{

203 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

204 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_clock_v1_message_proto_rawDesc), len(file_temporal_server_api_clock_v1_message_proto_rawDesc)),

205 > NumEnums: 0,

206 > NumMessages: 2,

207 > NumExtensions: 0,

208 > NumServices: 0,

209 > },

210 > GoTypes: file_temporal_server_api_clock_v1_message_proto_goTypes,

211 > DependencyIndexes: file_temporal_server_api_clock_v1_message_proto_depIdxs,

212 > MessageInfos: file_temporal_server_api_clock_v1_message_proto_msgTypes,

213 > }.Build()

214 > File_temporal_server_api_clock_v1_message_proto = out.File

215 > file_temporal_server_api_clock_v1_message_proto_goTypes = nil

216 > file_temporal_server_api_clock_v1_message_proto_depIdxs = nil

217 }

go.temporal.io/server/client/client_bean_mock.go 28 covered LOC · 7 ranges

Open complete file

34

35 // NewMockBean creates a new mock instance.

36 > func NewMockBean(ctrl *gomock.Controller) *MockBean { client_bean_mock.go

37 > mock := &MockBean{ctrl: ctrl}

38 > mock.recorder = &MockBeanMockRecorder{mock}

39 > return mock

40 > }

41

42 // EXPECT returns an object that allows the caller to indicate expected use.

43 > func (m *MockBean) EXPECT() *MockBeanMockRecorder { client_bean_mock.go

44 > return m.recorder

45 > }

46

47 // Close mocks base method.

66

67 // GetFrontendClient indicates an expected call of GetFrontendClient.

68 > func (mr *MockBeanMockRecorder) GetFrontendClient() *gomock.Call { client_bean_mock.go

69 > mr.mock.ctrl.T.Helper()

70 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFrontendClient", reflect.TypeOf((*MockBean)(nil).GetFrontendClient))

71 > }

72

73 // GetHistoryClient mocks base method.

80

81 // GetHistoryClient indicates an expected call of GetHistoryClient.

82 > func (mr *MockBeanMockRecorder) GetHistoryClient() *gomock.Call { client_bean_mock.go

83 > mr.mock.ctrl.T.Helper()

84 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryClient", reflect.TypeOf((*MockBean)(nil).GetHistoryClient))

85 > }

86

87 // GetMatchingClient mocks base method.

95

96 // GetMatchingClient indicates an expected call of GetMatchingClient.

97 > func (mr *MockBeanMockRecorder) GetMatchingClient(namespaceIDToName any) *gomock.Call { client_bean_mock.go

98 > mr.mock.ctrl.T.Helper()

99 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMatchingClient", reflect.TypeOf((*MockBean)(nil).GetMatchingClient), namespaceIDToName)

100 > }

101

102 // GetRemoteAdminClient mocks base method.

110

111 // GetRemoteAdminClient indicates an expected call of GetRemoteAdminClient.

112 > func (mr *MockBeanMockRecorder) GetRemoteAdminClient(arg0 any) *gomock.Call { client_bean_mock.go

113 > mr.mock.ctrl.T.Helper()

114 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteAdminClient", reflect.TypeOf((*MockBean)(nil).GetRemoteAdminClient), arg0)

115 > }

116

117 // GetRemoteFrontendClient mocks base method.

126

127 // GetRemoteFrontendClient indicates an expected call of GetRemoteFrontendClient.

128 > func (mr *MockBeanMockRecorder) GetRemoteFrontendClient(arg0 any) *gomock.Call { client_bean_mock.go

129 > mr.mock.ctrl.T.Helper()

130 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteFrontendClient", reflect.TypeOf((*MockBean)(nil).GetRemoteFrontendClient), arg0)

131 > }

go.temporal.io/server/service/history/shard/task_key_manager.go 28 covered LOC · 5 ranges

Open complete file

28 logger log.Logger,

29 renewRangeIDFn renewRangeIDFn,

30 > ) *taskKeyManager { task_key_manager.go

31 > return &taskKeyManager{

32 > generator: newTaskKeyGenerator(

33 > config.RangeSizeBits,

34 > timeSource,

35 > logger,

36 > renewRangeIDFn,

37 > ),

38 > tracker: newTaskRequestTracker(taskCategoryRegistry),

39 > timeSource: timeSource,

40 > logger: logger,

41 > config: config,

42 > }

43 > }

44

45 func (m *taskKeyManager) setAndTrackTaskKeys(

46 taskMaps ...map[tasks.Category][]tasks.Task,

47 > ) (taskRequestCompletionFn, error) { task_key_manager.go

48 >

49 > if err := m.generator.setTaskKeys(taskMaps...); err != nil {

50 return nil, err

51 }

52

53 > return m.tracker.track(taskMaps...), nil task_key_manager.go

54 }

55

56 func (m *taskKeyManager) peekTaskKey(

57 category tasks.Category,

58 > ) tasks.Key { task_key_manager.go

59 > return m.generator.peekTaskKey(category)

60 > }

61

62 func (m *taskKeyManager) generateTaskKey(

72 func (m *taskKeyManager) setRangeID(

73 rangeID int64,

74 > ) { task_key_manager.go

75 > m.generator.setRangeID(rangeID)

76 >

77 > // rangeID update means all pending add tasks requests either already succeeded

78 > // are guaranteed to fail, so we can clear pending requests in the tracker

79 > m.tracker.clear()

80 > }

81

82 func (m *taskKeyManager) setTaskMinScheduledTime(

go.temporal.io/server/service/history/workflow/task_generator.go 28 covered LOC · 7 ranges

Open complete file

115 archivalMetadata archiver.ArchivalMetadata,

116 logger log.Logger,

117 > ) *TaskGeneratorImpl { task_generator.go

118 > return &TaskGeneratorImpl{

119 > namespaceRegistry: namespaceRegistry,

120 > mutableState: mutableState,

121 > config: config,

122 > archivalMetadata: archivalMetadata,

123 > logger: logger,

124 > }

125 > }

126

127 func (r *TaskGeneratorImpl) GenerateWorkflowStartTasks(

295 func (r *TaskGeneratorImpl) GenerateDirtySubStateMachineTasks(

296 stateMachineRegistry *hsm.Registry,

297 > ) error { task_generator.go

298 > tree := r.mutableState.HSM()

299 > opLog, err := tree.OpLog()

300 > if err != nil {

301 return err

302 }

303

304 > for _, op := range opLog { task_generator.go

305 switch transitionOp := op.(type) {

306 case hsm.DeleteOperation:

329 }

330

331 > AddNextStateMachineTimerTask(r.mutableState) task_generator.go

332 >

333 > return nil

334 }

335

724 }

725

726 > func (r *TaskGeneratorImpl) GenerateActivityTimerTasks() error { task_generator.go

727 > _, err := r.getTimerSequence().CreateNextActivityTimer()

728 > return err

729 > }

730

731 > func (r *TaskGeneratorImpl) GenerateUserTimerTasks() error { task_generator.go

732 > _, err := r.getTimerSequence().CreateNextUserTimer()

733 > return err

734 > }

735

736 func (r *TaskGeneratorImpl) GenerateHistoryReplicationTasks(

893 }

894

895 > func (r *TaskGeneratorImpl) getTimerSequence() TimerSequence { task_generator.go

896 > return NewTimerSequence(r.mutableState)

897 > }

898

899 func (r *TaskGeneratorImpl) getTargetNamespaceID(

go.temporal.io/server/api/persistence/v1/queues.pb.go 27 covered LOC · 3 ranges

Open complete file

98 func (*QueueState) ProtoMessage() {}

99

100 > func (x *QueueState) ProtoReflect() protoreflect.Message { queues.pb.go

101 > mi := &file_temporal_server_api_persistence_v1_queues_proto_msgTypes[1]

102 > if x != nil {

103 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

104 if ms.LoadMessageInfo() == nil {

107 return ms

108 }

109 > return mi.MessageOf(x) queues.pb.go

110 }

111

616 }

617

618 > func init() { file_temporal_server_api_persistence_v1_queues_proto_init() } queues.pb.go

619 > func file_temporal_server_api_persistence_v1_queues_proto_init() {

620 > if File_temporal_server_api_persistence_v1_queues_proto != nil {

621 > return

622 > }

623 > file_temporal_server_api_persistence_v1_predicates_proto_init()

624 > type x struct{}

625 > out := protoimpl.TypeBuilder{

626 > File: protoimpl.DescBuilder{

627 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

628 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_queues_proto_rawDesc), len(file_temporal_server_api_persistence_v1_queues_proto_rawDesc)),

629 > NumEnums: 0,

630 > NumMessages: 12,

631 > NumExtensions: 0,

632 > NumServices: 0,

633 > },

634 > GoTypes: file_temporal_server_api_persistence_v1_queues_proto_goTypes,

635 > DependencyIndexes: file_temporal_server_api_persistence_v1_queues_proto_depIdxs,

636 > MessageInfos: file_temporal_server_api_persistence_v1_queues_proto_msgTypes,

637 > }.Build()

638 > File_temporal_server_api_persistence_v1_queues_proto = out.File

639 > file_temporal_server_api_persistence_v1_queues_proto_goTypes = nil

640 > file_temporal_server_api_persistence_v1_queues_proto_depIdxs = nil

641 }

go.temporal.io/server/api/enums/v1/common.pb.go 26 covered LOC · 4 ranges

Open complete file

120 }

121

122 > func (ChecksumFlavor) Descriptor() protoreflect.EnumDescriptor { common.pb.go

123 > return file_temporal_server_api_enums_v1_common_proto_enumTypes[1].Descriptor()

124 > }

125

126 func (ChecksumFlavor) Type() protoreflect.EnumType {

201 }

202

203 > func (CallbackState) Descriptor() protoreflect.EnumDescriptor { common.pb.go

204 > return file_temporal_server_api_enums_v1_common_proto_enumTypes[2].Descriptor()

205 > }

206

207 func (CallbackState) Type() protoreflect.EnumType {

264 }

265

266 > func init() { file_temporal_server_api_enums_v1_common_proto_init() } common.pb.go

267 > func file_temporal_server_api_enums_v1_common_proto_init() {

268 > if File_temporal_server_api_enums_v1_common_proto != nil {

269 return

270 }

271 > type x struct{} common.pb.go

272 > out := protoimpl.TypeBuilder{

273 > File: protoimpl.DescBuilder{

274 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

275 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_common_proto_rawDesc), len(file_temporal_server_api_enums_v1_common_proto_rawDesc)),

276 > NumEnums: 3,

277 > NumMessages: 0,

278 > NumExtensions: 0,

279 > NumServices: 0,

280 > },

281 > GoTypes: file_temporal_server_api_enums_v1_common_proto_goTypes,

282 > DependencyIndexes: file_temporal_server_api_enums_v1_common_proto_depIdxs,

283 > EnumInfos: file_temporal_server_api_enums_v1_common_proto_enumTypes,

284 > }.Build()

285 > File_temporal_server_api_enums_v1_common_proto = out.File

286 > file_temporal_server_api_enums_v1_common_proto_goTypes = nil

287 > file_temporal_server_api_enums_v1_common_proto_depIdxs = nil

288 }

go.temporal.io/server/api/enums/v1/workflow.pb.go 26 covered LOC · 4 ranges

Open complete file

86 }

87

88 > func (WorkflowExecutionState) Descriptor() protoreflect.EnumDescriptor { workflow.pb.go

89 > return file_temporal_server_api_enums_v1_workflow_proto_enumTypes[0].Descriptor()

90 > }

91

92 func (WorkflowExecutionState) Type() protoreflect.EnumType {

150 }

151

152 > func (WorkflowBackoffType) Descriptor() protoreflect.EnumDescriptor { workflow.pb.go

153 > return file_temporal_server_api_enums_v1_workflow_proto_enumTypes[1].Descriptor()

154 > }

155

156 func (WorkflowBackoffType) Type() protoreflect.EnumType {

275 }

276

277 > func init() { file_temporal_server_api_enums_v1_workflow_proto_init() } workflow.pb.go

278 > func file_temporal_server_api_enums_v1_workflow_proto_init() {

279 > if File_temporal_server_api_enums_v1_workflow_proto != nil {

280 return

281 }

282 > type x struct{} workflow.pb.go

283 > out := protoimpl.TypeBuilder{

284 > File: protoimpl.DescBuilder{

285 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

286 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_proto_rawDesc)),

287 > NumEnums: 3,

288 > NumMessages: 0,

289 > NumExtensions: 0,

290 > NumServices: 0,

291 > },

292 > GoTypes: file_temporal_server_api_enums_v1_workflow_proto_goTypes,

293 > DependencyIndexes: file_temporal_server_api_enums_v1_workflow_proto_depIdxs,

294 > EnumInfos: file_temporal_server_api_enums_v1_workflow_proto_enumTypes,

295 > }.Build()

296 > File_temporal_server_api_enums_v1_workflow_proto = out.File

297 > file_temporal_server_api_enums_v1_workflow_proto_goTypes = nil

298 > file_temporal_server_api_enums_v1_workflow_proto_depIdxs = nil

299 }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/message.pb.go 26 covered LOC · 1 range

Open complete file

843 }

844

845 > func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init() } message.pb.go

846 > func file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init() {

847 > if File_temporal_server_chasm_lib_scheduler_proto_v1_message_proto != nil {

848 > return

849 > }

850 > file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_msgTypes[4].OneofWrappers = []any{

851 > (*BackfillerState_BackfillRequest)(nil),

852 > (*BackfillerState_TriggerRequest)(nil),

853 > }

854 > type x struct{}

855 > out := protoimpl.TypeBuilder{

856 > File: protoimpl.DescBuilder{

857 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

858 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_rawDesc)),

859 > NumEnums: 0,

860 > NumMessages: 12,

861 > NumExtensions: 0,

862 > NumServices: 0,

863 > },

864 > GoTypes: file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_goTypes,

865 > DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_depIdxs,

866 > MessageInfos: file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_msgTypes,

867 > }.Build()

868 > File_temporal_server_chasm_lib_scheduler_proto_v1_message_proto = out.File

869 > file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_goTypes = nil

870 > file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_depIdxs = nil

871 }

go.temporal.io/server/common/membership/interfaces_mock.go 26 covered LOC · 6 ranges

Open complete file

32

33 // NewMockMonitor creates a new mock instance.

34 > func NewMockMonitor(ctrl *gomock.Controller) *MockMonitor { interfaces_mock.go

35 > mock := &MockMonitor{ctrl: ctrl}

36 > mock.recorder = &MockMonitorMockRecorder{mock}

37 > return mock

38 > }

39

40 // EXPECT returns an object that allows the caller to indicate expected use.

41 > func (m *MockMonitor) EXPECT() *MockMonitorMockRecorder { interfaces_mock.go

42 > return m.recorder

43 > }

44

45 // ApproximateMaxPropagationTime mocks base method.

111

112 // GetResolver indicates an expected call of GetResolver.

113 > func (mr *MockMonitorMockRecorder) GetResolver(service any) *gomock.Call { interfaces_mock.go

114 > mr.mock.ctrl.T.Helper()

115 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolver", reflect.TypeOf((*MockMonitor)(nil).GetResolver), service)

116 > }

117

118 // SetDraining mocks base method.

151

152 // WaitUntilInitialized indicates an expected call of WaitUntilInitialized.

153 > func (mr *MockMonitorMockRecorder) WaitUntilInitialized(arg0 any) *gomock.Call { interfaces_mock.go

154 > mr.mock.ctrl.T.Helper()

155 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInitialized", reflect.TypeOf((*MockMonitor)(nil).WaitUntilInitialized), arg0)

156 > }

157

158 // MockServiceResolver is a mock of ServiceResolver interface.

169

170 // NewMockServiceResolver creates a new mock instance.

171 > func NewMockServiceResolver(ctrl *gomock.Controller) *MockServiceResolver { interfaces_mock.go

172 > mock := &MockServiceResolver{ctrl: ctrl}

173 > mock.recorder = &MockServiceResolverMockRecorder{mock}

174 > return mock

175 > }

176

177 // EXPECT returns an object that allows the caller to indicate expected use.

318

319 // NewMockHostInfoProvider creates a new mock instance.

320 > func NewMockHostInfoProvider(ctrl *gomock.Controller) *MockHostInfoProvider { interfaces_mock.go

321 > mock := &MockHostInfoProvider{ctrl: ctrl}

322 > mock.recorder = &MockHostInfoProviderMockRecorder{mock}

323 > return mock

324 > }

325

326 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/namespace/replication_resolver.go 26 covered LOC · 6 ranges

Open complete file

49 }

50

51 > func NewDefaultReplicationResolverFactory() ReplicationResolverFactory { replication_resolver.go

52 > return func(detail *persistencespb.NamespaceDetail) ReplicationResolver {

53 > // By convention, a namespace with non-zero failover version is a global namespace

54 > // This can be overridden by WithGlobalFlag mutation if needed

55 > isGlobal := detail.FailoverVersion != 0

56 > return &defaultReplicationResolver{

57 > replicationConfig: detail.ReplicationConfig,

58 > isGlobalNamespace: isGlobal,

59 > failoverVersion: detail.FailoverVersion,

60 > failoverNotificationVersion: detail.FailoverNotificationVersion,

61 > }

62 > }

63 }

64

79 }

80

81 > func (r *defaultReplicationResolver) ClusterNames(businessID string) []string { replication_resolver.go

82 > if r.replicationConfig == nil {

83 return nil

84 }

85 // copy slice to preserve immutability

86 > out := make([]string, len(r.replicationConfig.Clusters)) replication_resolver.go

87 > copy(out, r.replicationConfig.Clusters)

88 > return out

89 }

90

96 }

97

98 > func (r *defaultReplicationResolver) IsGlobalNamespace() bool { replication_resolver.go

99 > return r.isGlobalNamespace

100 > }

101

102 > func (r *defaultReplicationResolver) FailoverVersion(businessID string) int64 { replication_resolver.go

103 > return r.failoverVersion

104 > }

105

106 func (r *defaultReplicationResolver) FailoverNotificationVersion() int64 {

112 }

113

114 > func (r *defaultReplicationResolver) SetGlobalFlag(isGlobal bool) { replication_resolver.go

115 > r.isGlobalNamespace = isGlobal

116 > }

117

118 func (r *defaultReplicationResolver) SetActiveCluster(clusterName string) {

go.temporal.io/server/chasm/context.go 25 covered LOC · 4 ranges

Open complete file

133 ctx context.Context,

134 node *Node,

135 > ) Context { context.go

136 > return newContext(ctx, node)

137 > }

138

139 // newContext creates a new immutableCtx from an existing Context and root Node.

142 ctx context.Context,

143 node *Node,

144 > ) *immutableCtx { context.go

145 > root := node.root()

146 > workflowKey := node.backend.GetWorkflowKey()

147 > return &immutableCtx{

148 > ctx: ctx,

149 > now: root.Now(nil),

150 > root: root,

151 > executionKey: ExecutionKey{

152 > NamespaceID: workflowKey.NamespaceID,

153 > BusinessID: workflowKey.WorkflowID,

154 > RunID: workflowKey.RunID,

155 > },

156 > }

157 > }

158

159 func (c *immutableCtx) Ref(component Component) ([]byte, error) {

230 }

231

232 > func (c *immutableCtx) goContext() context.Context { context.go

233 > return c.ctx

234 > }

235

236 func (c *immutableCtx) RequestHeader(key string) string {

256 ctx context.Context,

257 node *Node,

258 > ) MutableContext { context.go

259 > return &mutableCtx{

260 > immutableCtx: newContext(ctx, node),

261 > }

262 > }

263

264 func (c *mutableCtx) AddTask(

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/activity_state.pb.go 25 covered LOC · 2 ranges

Open complete file

1382 }

1383

1384 > func init() { file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_init() } activity_state.pb.go

1385 > func file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_init() {

1386 > if File_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto != nil {

1387 return

1388 }

1389 > file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_msgTypes[7].OneofWrappers = []any{ activity_state.pb.go

1390 > (*ActivityOutcome_Successful_)(nil),

1391 > (*ActivityOutcome_Failed_)(nil),

1392 > }

1393 > type x struct{}

1394 > out := protoimpl.TypeBuilder{

1395 > File: protoimpl.DescBuilder{

1396 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

1397 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_rawDesc)),

1398 > NumEnums: 2,

1399 > NumMessages: 11,

1400 > NumExtensions: 0,

1401 > NumServices: 0,

1402 > },

1403 > GoTypes: file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_goTypes,

1404 > DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_depIdxs,

1405 > EnumInfos: file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_enumTypes,

1406 > MessageInfos: file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_msgTypes,

1407 > }.Build()

1408 > File_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto = out.File

1409 > file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_goTypes = nil

1410 > file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_depIdxs = nil

1411 }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/operation.pb.go 25 covered LOC · 2 ranges

Open complete file

998 }

999

1000 > func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_init() } operation.pb.go

1001 > func file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_init() {

1002 > if File_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto != nil {

1003 return

1004 }

1005 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_msgTypes[2].OneofWrappers = []any{ operation.pb.go

1006 > (*OperationOutcome_Successful_)(nil),

1007 > (*OperationOutcome_Failed_)(nil),

1008 > }

1009 > type x struct{}

1010 > out := protoimpl.TypeBuilder{

1011 > File: protoimpl.DescBuilder{

1012 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

1013 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_rawDesc)),

1014 > NumEnums: 2,

1015 > NumMessages: 8,

1016 > NumExtensions: 0,

1017 > NumServices: 0,

1018 > },

1019 > GoTypes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_goTypes,

1020 > DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_depIdxs,

1021 > EnumInfos: file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_enumTypes,

1022 > MessageInfos: file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_msgTypes,

1023 > }.Build()

1024 > File_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto = out.File

1025 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_goTypes = nil

1026 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_depIdxs = nil

1027 }

go.temporal.io/server/common/persistence/serialization/codec.go 25 covered LOC · 10 ranges

Open complete file

26 // encodingTypeFromEnv returns an EncodingType based on the environment variable `TEMPORAL_TEST_DATA_ENCODING`.

27 // It defaults to "ENCODING_TYPE_PROTO3" codec if the environment variable is not set.

28 > func encodingTypeFromEnv() enumspb.EncodingType { codec.go

29 > codecType := os.Getenv(SerializerDataEncodingEnvVar)

30 > switch strings.ToLower(codecType) {

31 > case "", "proto3": codec.go

32 > return enumspb.ENCODING_TYPE_PROTO3

33 case "json":

34 return enumspb.ENCODING_TYPE_JSON

51 // a reliable equality check for any well-formed proto message. For messages

52 // without map fields this is a no-op with no performance overhead.

53 > var WithDeterministicProto3 EncodeOption = func(opts *encodeOptions) { codec.go

54 > opts.deterministic = true

55 > }

56

57 // Encode encodes the given proto message. It respects the `TEMPORAL_TEST_DATA_ENCODING` environment variable;

58 // otherwise, it defaults to "ENCODING_TYPE_PROTO3".

59 > func Encode(m proto.Message, options ...EncodeOption) (*commonpb.DataBlob, error) { codec.go

60 > return encodeBlob(m, encodingTypeFromEnv(), options...)

61 > }

62

63 func encodeBlob(

65 encoding enumspb.EncodingType,

66 options ...EncodeOption,

67 > ) (*commonpb.DataBlob, error) { codec.go

68 > opts := encodeOptions{}

69 > for _, option := range options {

70 > option(&opts) codec.go

71 > }

72

73 > if m == nil { codec.go

74 return &commonpb.DataBlob{

75 Data: nil,

78 }

79

80 > switch encoding { codec.go

81 case enumspb.ENCODING_TYPE_JSON:

82 blob, err := codec.NewJSONPBEncoder().Encode(m)

88 EncodingType: enumspb.ENCODING_TYPE_JSON,

89 }, nil

90 > case enumspb.ENCODING_TYPE_PROTO3: codec.go

91 > data, err := proto.MarshalOptions{Deterministic: opts.deterministic}.Marshal(m)

92 > if err != nil {

93 return nil, NewSerializationError(enumspb.ENCODING_TYPE_PROTO3, err)

94 }

95 > return &commonpb.DataBlob{ codec.go

96 > EncodingType: enumspb.ENCODING_TYPE_PROTO3,

97 > Data: data,

98 > }, nil

99 default:

100 return nil, NewUnknownEncodingTypeError(encoding.String(), enumspb.ENCODING_TYPE_JSON, enumspb.ENCODING_TYPE_PROTO3)

go.temporal.io/server/common/routing/route.go 25 covered LOC · 8 ranges

Open complete file

36

37 // NewRoute returns a new [Route] instance with the given components.

38 > func NewRoute[T any](components ...Component[T]) Route[T] { route.go

39 > return Route[T]{components: components}

40 > }

41

42 // RouteBuilder is a builder for the [Route] interface.

46

47 // NewBuilder creates a new [RouteBuilder] instance, which can be used to define a new [Route] via a fluent API.

48 > func NewBuilder[T any]() *RouteBuilder[T] { route.go

49 > return &RouteBuilder[T]{}

50 > }

51

52 // With adds a series of [Component] instances to the [Route].

53 > func (r *RouteBuilder[T]) With(c ...Component[T]) *RouteBuilder[T] { route.go

54 > r.components = append(r.components, c...)

55 > return r

56 > }

57

58 // Constant adds a [Constant] component to the [Route].

59 > func (r *RouteBuilder[T]) Constant(values ...string) *RouteBuilder[T] { route.go

60 > return r.With(Constant[T](values...))

61 > }

62

63 // StringVariable adds a [StringVariable] component to the [Route].

64 > func (r *RouteBuilder[T]) StringVariable(name string, getter func(*T) *string) *RouteBuilder[T] { route.go

65 > return r.With(StringVariable[T](name, getter))

66 > }

67

68 // Build returns a read-only [Route].

69 > func (r *RouteBuilder[T]) Build() Route[T] { route.go

70 > return NewRoute[T](r.components...)

71 > }

72

73 // Representation returns the [github.com/gorilla/mux] compatible string representation of the route for usage in a

111 // Constant returns a [Component] that represents a series of constant HTTP path components in a Route.

112 // They will be joined via strings when used to construct a path or path representation.

113 > func Constant[T any](values ...string) constant[T] { route.go

114 > return values

115 > }

116

117 type constant[T any] []string

128

129 // StringVariable returns a [Component] that represents a string variable in a Route.

130 > func StringVariable[T any](name string, getter func(*T) *string) stringVariable[T] { route.go

131 > return stringVariable[T]{name, getter}

132 > }

133

134 type stringVariable[T any] struct {

go.temporal.io/server/api/persistence/v1/nexus.pb.go 24 covered LOC · 2 ranges

Open complete file

481 }

482

483 > func init() { file_temporal_server_api_persistence_v1_nexus_proto_init() } nexus.pb.go

484 > func file_temporal_server_api_persistence_v1_nexus_proto_init() {

485 > if File_temporal_server_api_persistence_v1_nexus_proto != nil {

486 return

487 }

488 > file_temporal_server_api_persistence_v1_nexus_proto_msgTypes[1].OneofWrappers = []any{ nexus.pb.go

489 > (*NexusEndpointTarget_Worker_)(nil),

490 > (*NexusEndpointTarget_External_)(nil),

491 > }

492 > type x struct{}

493 > out := protoimpl.TypeBuilder{

494 > File: protoimpl.DescBuilder{

495 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

496 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_nexus_proto_rawDesc), len(file_temporal_server_api_persistence_v1_nexus_proto_rawDesc)),

497 > NumEnums: 0,

498 > NumMessages: 6,

499 > NumExtensions: 0,

500 > NumServices: 0,

501 > },

502 > GoTypes: file_temporal_server_api_persistence_v1_nexus_proto_goTypes,

503 > DependencyIndexes: file_temporal_server_api_persistence_v1_nexus_proto_depIdxs,

504 > MessageInfos: file_temporal_server_api_persistence_v1_nexus_proto_msgTypes,

505 > }.Build()

506 > File_temporal_server_api_persistence_v1_nexus_proto = out.File

507 > file_temporal_server_api_persistence_v1_nexus_proto_goTypes = nil

508 > file_temporal_server_api_persistence_v1_nexus_proto_depIdxs = nil

509 }

go.temporal.io/server/api/persistence/v1/workflow_mutable_state.pb.go 24 covered LOC · 2 ranges

Open complete file

532 }

533

534 > func init() { file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_init() } workflow_mutable_state.pb.go

535 > func file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_init() {

536 > if File_temporal_server_api_persistence_v1_workflow_mutable_state_proto != nil {

537 return

538 }

539 > file_temporal_server_api_persistence_v1_chasm_proto_init() workflow_mutable_state.pb.go

540 > file_temporal_server_api_persistence_v1_executions_proto_init()

541 > file_temporal_server_api_persistence_v1_hsm_proto_init()

542 > file_temporal_server_api_persistence_v1_update_proto_init()

543 > type x struct{}

544 > out := protoimpl.TypeBuilder{

545 > File: protoimpl.DescBuilder{

546 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

547 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_rawDesc), len(file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_rawDesc)),

548 > NumEnums: 0,

549 > NumMessages: 16,

550 > NumExtensions: 0,

551 > NumServices: 0,

552 > },

553 > GoTypes: file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_goTypes,

554 > DependencyIndexes: file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_depIdxs,

555 > MessageInfos: file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_msgTypes,

556 > }.Build()

557 > File_temporal_server_api_persistence_v1_workflow_mutable_state_proto = out.File

558 > file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_goTypes = nil

559 > file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_depIdxs = nil

560 }

go.temporal.io/server/api/schedule/v1/message.pb.go 24 covered LOC · 2 ranges

Open complete file

1224 }

1225

1226 > func init() { file_temporal_server_api_schedule_v1_message_proto_init() } message.pb.go

1227 > func file_temporal_server_api_schedule_v1_message_proto_init() {

1228 > if File_temporal_server_api_schedule_v1_message_proto != nil {

1229 return

1230 }

1231 > file_temporal_server_api_schedule_v1_message_proto_msgTypes[7].OneofWrappers = []any{ message.pb.go

1232 > (*WatchWorkflowResponse_Result)(nil),

1233 > (*WatchWorkflowResponse_Failure)(nil),

1234 > }

1235 > type x struct{}

1236 > out := protoimpl.TypeBuilder{

1237 > File: protoimpl.DescBuilder{

1238 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

1239 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_schedule_v1_message_proto_rawDesc), len(file_temporal_server_api_schedule_v1_message_proto_rawDesc)),

1240 > NumEnums: 0,

1241 > NumMessages: 13,

1242 > NumExtensions: 0,

1243 > NumServices: 0,

1244 > },

1245 > GoTypes: file_temporal_server_api_schedule_v1_message_proto_goTypes,

1246 > DependencyIndexes: file_temporal_server_api_schedule_v1_message_proto_depIdxs,

1247 > MessageInfos: file_temporal_server_api_schedule_v1_message_proto_msgTypes,

1248 > }.Build()

1249 > File_temporal_server_api_schedule_v1_message_proto = out.File

1250 > file_temporal_server_api_schedule_v1_message_proto_goTypes = nil

1251 > file_temporal_server_api_schedule_v1_message_proto_depIdxs = nil

1252 }

go.temporal.io/server/api/workflow/v1/message.pb.go 24 covered LOC · 4 ranges

Open complete file

189 func (*BaseExecutionInfo) ProtoMessage() {}

190

191 > func (x *BaseExecutionInfo) ProtoReflect() protoreflect.Message { message.pb.go

192 > mi := &file_temporal_server_api_workflow_v1_message_proto_msgTypes[2]

193 > if x != nil {

194 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

195 if ms.LoadMessageInfo() == nil {

198 return ms

199 }

200 > return mi.MessageOf(x) message.pb.go

201 }

202

278 }

279

280 > func init() { file_temporal_server_api_workflow_v1_message_proto_init() } message.pb.go

281 > func file_temporal_server_api_workflow_v1_message_proto_init() {

282 > if File_temporal_server_api_workflow_v1_message_proto != nil {

283 return

284 }

285 > type x struct{} message.pb.go

286 > out := protoimpl.TypeBuilder{

287 > File: protoimpl.DescBuilder{

288 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

289 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_workflow_v1_message_proto_rawDesc), len(file_temporal_server_api_workflow_v1_message_proto_rawDesc)),

290 > NumEnums: 0,

291 > NumMessages: 3,

292 > NumExtensions: 0,

293 > NumServices: 0,

294 > },

295 > GoTypes: file_temporal_server_api_workflow_v1_message_proto_goTypes,

296 > DependencyIndexes: file_temporal_server_api_workflow_v1_message_proto_depIdxs,

297 > MessageInfos: file_temporal_server_api_workflow_v1_message_proto_msgTypes,

298 > }.Build()

299 > File_temporal_server_api_workflow_v1_message_proto = out.File

300 > file_temporal_server_api_workflow_v1_message_proto_goTypes = nil

301 > file_temporal_server_api_workflow_v1_message_proto_depIdxs = nil

302 }

go.temporal.io/server/chasm/lib/callback/gen/callbackpb/v1/message.pb.go 24 covered LOC · 2 ranges

Open complete file

462 }

463

464 > func init() { file_temporal_server_chasm_lib_callback_proto_v1_message_proto_init() } message.pb.go

465 > func file_temporal_server_chasm_lib_callback_proto_v1_message_proto_init() {

466 > if File_temporal_server_chasm_lib_callback_proto_v1_message_proto != nil {

467 return

468 }

469 > file_temporal_server_chasm_lib_callback_proto_v1_message_proto_msgTypes[1].OneofWrappers = []any{ message.pb.go

470 > (*Callback_Nexus_)(nil),

471 > }

472 > type x struct{}

473 > out := protoimpl.TypeBuilder{

474 > File: protoimpl.DescBuilder{

475 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

476 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_callback_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_callback_proto_v1_message_proto_rawDesc)),

477 > NumEnums: 1,

478 > NumMessages: 5,

479 > NumExtensions: 0,

480 > NumServices: 0,

481 > },

482 > GoTypes: file_temporal_server_chasm_lib_callback_proto_v1_message_proto_goTypes,

483 > DependencyIndexes: file_temporal_server_chasm_lib_callback_proto_v1_message_proto_depIdxs,

484 > EnumInfos: file_temporal_server_chasm_lib_callback_proto_v1_message_proto_enumTypes,

485 > MessageInfos: file_temporal_server_chasm_lib_callback_proto_v1_message_proto_msgTypes,

486 > }.Build()

487 > File_temporal_server_chasm_lib_callback_proto_v1_message_proto = out.File

488 > file_temporal_server_chasm_lib_callback_proto_v1_message_proto_goTypes = nil

489 > file_temporal_server_chasm_lib_callback_proto_v1_message_proto_depIdxs = nil

490 }

go.temporal.io/server/api/enums/v1/nexus.pb.go 23 covered LOC · 3 ranges

Open complete file

102 }

103

104 > func (NexusOperationState) Descriptor() protoreflect.EnumDescriptor { nexus.pb.go

105 > return file_temporal_server_api_enums_v1_nexus_proto_enumTypes[0].Descriptor()

106 > }

107

108 func (NexusOperationState) Type() protoreflect.EnumType {

158 }

159

160 > func init() { file_temporal_server_api_enums_v1_nexus_proto_init() } nexus.pb.go

161 > func file_temporal_server_api_enums_v1_nexus_proto_init() {

162 > if File_temporal_server_api_enums_v1_nexus_proto != nil {

163 return

164 }

165 > type x struct{} nexus.pb.go

166 > out := protoimpl.TypeBuilder{

167 > File: protoimpl.DescBuilder{

168 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

169 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_nexus_proto_rawDesc), len(file_temporal_server_api_enums_v1_nexus_proto_rawDesc)),

170 > NumEnums: 1,

171 > NumMessages: 0,

172 > NumExtensions: 0,

173 > NumServices: 0,

174 > },

175 > GoTypes: file_temporal_server_api_enums_v1_nexus_proto_goTypes,

176 > DependencyIndexes: file_temporal_server_api_enums_v1_nexus_proto_depIdxs,

177 > EnumInfos: file_temporal_server_api_enums_v1_nexus_proto_enumTypes,

178 > }.Build()

179 > File_temporal_server_api_enums_v1_nexus_proto = out.File

180 > file_temporal_server_api_enums_v1_nexus_proto_goTypes = nil

181 > file_temporal_server_api_enums_v1_nexus_proto_depIdxs = nil

182 }

go.temporal.io/server/api/enums/v1/predicate.pb.go 23 covered LOC · 3 ranges

Open complete file

111 }

112

113 > func (PredicateType) Descriptor() protoreflect.EnumDescriptor { predicate.pb.go

114 > return file_temporal_server_api_enums_v1_predicate_proto_enumTypes[0].Descriptor()

115 > }

116

117 func (PredicateType) Type() protoreflect.EnumType {

170 }

171

172 > func init() { file_temporal_server_api_enums_v1_predicate_proto_init() } predicate.pb.go

173 > func file_temporal_server_api_enums_v1_predicate_proto_init() {

174 > if File_temporal_server_api_enums_v1_predicate_proto != nil {

175 return

176 }

177 > type x struct{} predicate.pb.go

178 > out := protoimpl.TypeBuilder{

179 > File: protoimpl.DescBuilder{

180 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

181 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_predicate_proto_rawDesc), len(file_temporal_server_api_enums_v1_predicate_proto_rawDesc)),

182 > NumEnums: 1,

183 > NumMessages: 0,

184 > NumExtensions: 0,

185 > NumServices: 0,

186 > },

187 > GoTypes: file_temporal_server_api_enums_v1_predicate_proto_goTypes,

188 > DependencyIndexes: file_temporal_server_api_enums_v1_predicate_proto_depIdxs,

189 > EnumInfos: file_temporal_server_api_enums_v1_predicate_proto_enumTypes,

190 > }.Build()

191 > File_temporal_server_api_enums_v1_predicate_proto = out.File

192 > file_temporal_server_api_enums_v1_predicate_proto_goTypes = nil

193 > file_temporal_server_api_enums_v1_predicate_proto_depIdxs = nil

194 }

go.temporal.io/server/api/enums/v1/workflow_task_type.pb.go 23 covered LOC · 3 ranges

Open complete file

72 }

73

74 > func (WorkflowTaskType) Descriptor() protoreflect.EnumDescriptor { workflow_task_type.pb.go

75 > return file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes[0].Descriptor()

76 > }

77

78 func (WorkflowTaskType) Type() protoreflect.EnumType {

124 }

125

126 > func init() { file_temporal_server_api_enums_v1_workflow_task_type_proto_init() } workflow_task_type.pb.go

127 > func file_temporal_server_api_enums_v1_workflow_task_type_proto_init() {

128 > if File_temporal_server_api_enums_v1_workflow_task_type_proto != nil {

129 return

130 }

131 > type x struct{} workflow_task_type.pb.go

132 > out := protoimpl.TypeBuilder{

133 > File: protoimpl.DescBuilder{

134 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

135 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc)),

136 > NumEnums: 1,

137 > NumMessages: 0,

138 > NumExtensions: 0,

139 > NumServices: 0,

140 > },

141 > GoTypes: file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes,

142 > DependencyIndexes: file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs,

143 > EnumInfos: file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes,

144 > }.Build()

145 > File_temporal_server_api_enums_v1_workflow_task_type_proto = out.File

146 > file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes = nil

147 > file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs = nil

148 }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/request_response.pb.go 23 covered LOC · 1 range

Open complete file

1021 }

1022

1023 > func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init() } request_response.pb.go

1024 > func file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init() {

1025 > if File_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto != nil {

1026 > return

1027 > }

1028 > file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init()

1029 > type x struct{}

1030 > out := protoimpl.TypeBuilder{

1031 > File: protoimpl.DescBuilder{

1032 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

1033 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_rawDesc)),

1034 > NumEnums: 0,

1035 > NumMessages: 18,

1036 > NumExtensions: 0,

1037 > NumServices: 0,

1038 > },

1039 > GoTypes: file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_goTypes,

1040 > DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_depIdxs,

1041 > MessageInfos: file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_msgTypes,

1042 > }.Build()

1043 > File_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto = out.File

1044 > file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_goTypes = nil

1045 > file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_depIdxs = nil

1046 }

go.temporal.io/server/common/dynamicconfig/shared_structure.go 23 covered LOC · 6 ranges

Open complete file

17 )

18

19 > func warnDefaultSharedStructure(key string, def any) { shared_structure.go

20 > if path := hasSharedStructure(reflect.ValueOf(def), "root"); path != "" {

21 sharedStructureWarnings.Store(key, path)

22 }

23 }

24

25 > func logSharedStructureWarnings(logger log.Logger) { shared_structure.go

26 > // If you see this warning, it means that a default value used in New*TypedSetting has a

27 > // non-nil slice or map in it. That can lead to confusing behavior since the value from

28 > // dynamic config will be merged over the default value (e.g. the slice will be appended

29 > // to, not replaced). If that behavior is desired, you can avoid this warning by using

30 > // New*TypedSettingWithConverter and referring to dynamicconfig.ConvertStructure

31 > // explicitly. Otherwise use nil slices and maps, including at the top level

32 > // (so `[]string(nil)` instead of `[]string{}`).

33 > logSharedStructureWarningsOnce.Do(func() {

34 > sharedStructureWarnings.Range(func(key, path any) bool {

35 softassert.Fail(logger,

36 "default value contains shared structure",

42 }

43

44 > func hasSharedStructure(v reflect.Value, path string) string { shared_structure.go

45 > // nolint:exhaustive // deliberately not exhaustive

46 > switch v.Kind() {

47 > case reflect.Map, reflect.Slice, reflect.Pointer:

48 > if !v.IsNil() {

49 return path

50 }

51 > case reflect.Interface: shared_structure.go

52 > if !v.IsNil() {

53 return hasSharedStructure(v.Elem(), path)

54 }

55 > case reflect.Struct: shared_structure.go

56 > for i := range v.NumField() {

57 > if p := hasSharedStructure(v.Field(i), path+"."+v.Type().Field(i).Name); p != "" {

58 return p

59 }

66 }

67 }

68 > return "" shared_structure.go

69 }

go.temporal.io/server/common/log/tag/zap_tag.go 23 covered LOC · 5 ranges

Open complete file

26 }

27

28 > func (t ZapTag) Field() zap.Field { zap_tag.go

29 > return t.field

30 > }

31

32 func (t ZapTag) Key() string {

44 }

45

46 > func NewStringTag(key string, value string) ZapTag { zap_tag.go

47 > return ZapTag{

48 > field: zap.String(key, value),

49 > }

50 > }

51

52 func NewStringsTag(key string, value []string) ZapTag {

82 }

83

84 > func NewInt64(key string, value int64) ZapTag { zap_tag.go

85 > return ZapTag{

86 > field: zap.Int64(key, value),

87 > }

88 > }

89

90 func NewInt(key string, value int) ZapTag {

118 }

119

120 > func NewBoolTag(key string, value bool) ZapTag { zap_tag.go

121 > return ZapTag{

122 > field: zap.Bool(key, value),

123 > }

124 > }

125

126 func NewErrorTag(key string, value error) ZapTag {

142 }

143

144 > func NewTimeTag(key string, value time.Time) ZapTag { zap_tag.go

145 > return ZapTag{

146 > field: zap.Time(key, value),

147 > }

148 > }

149

150 func NewTimePtrTag(key string, value *timestamppb.Timestamp) ZapTag {

go.temporal.io/server/common/namespace/registry_mock.go 23 covered LOC · 5 ranges

Open complete file

30

31 // NewMockRegistry creates a new mock instance.

32 > func NewMockRegistry(ctrl *gomock.Controller) *MockRegistry { registry_mock.go

33 > mock := &MockRegistry{ctrl: ctrl}

34 > mock.recorder = &MockRegistryMockRecorder{mock}

35 > return mock

36 > }

37

38 // EXPECT returns an object that allows the caller to indicate expected use.

39 > func (m *MockRegistry) EXPECT() *MockRegistryMockRecorder { registry_mock.go

40 > return m.recorder

41 > }

42

43 // GetAllNamespaces mocks base method.

80

81 // GetNamespace indicates an expected call of GetNamespace.

82 > func (mr *MockRegistryMockRecorder) GetNamespace(name any) *gomock.Call { registry_mock.go

83 > mr.mock.ctrl.T.Helper()

84 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockRegistry)(nil).GetNamespace), name)

85 > }

86

87 // GetNamespaceByID mocks base method.

88 > func (m *MockRegistry) GetNamespaceByID(id ID) (*Namespace, error) { registry_mock.go

89 > m.ctrl.T.Helper()

90 > ret := m.ctrl.Call(m, "GetNamespaceByID", id)

91 > ret0, _ := ret[0].(*Namespace)

92 > ret1, _ := ret[1].(error)

93 > return ret0, ret1

94 > }

95

96 // GetNamespaceByID indicates an expected call of GetNamespaceByID.

97 > func (mr *MockRegistryMockRecorder) GetNamespaceByID(id any) *gomock.Call { registry_mock.go

98 > mr.mock.ctrl.T.Helper()

99 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceByID", reflect.TypeOf((*MockRegistry)(nil).GetNamespaceByID), id)

100 > }

101

102 // GetNamespaceByIDWithOptions mocks base method.

go.temporal.io/server/api/common/v1/api_category.pb.go 22 covered LOC · 2 ranges

Open complete file

204 }

205

206 > func init() { file_temporal_server_api_common_v1_api_category_proto_init() } api_category.pb.go

207 > func file_temporal_server_api_common_v1_api_category_proto_init() {

208 > if File_temporal_server_api_common_v1_api_category_proto != nil {

209 return

210 }

211 > type x struct{} api_category.pb.go

212 > out := protoimpl.TypeBuilder{

213 > File: protoimpl.DescBuilder{

214 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

215 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_common_v1_api_category_proto_rawDesc), len(file_temporal_server_api_common_v1_api_category_proto_rawDesc)),

216 > NumEnums: 1,

217 > NumMessages: 1,

218 > NumExtensions: 1,

219 > NumServices: 0,

220 > },

221 > GoTypes: file_temporal_server_api_common_v1_api_category_proto_goTypes,

222 > DependencyIndexes: file_temporal_server_api_common_v1_api_category_proto_depIdxs,

223 > EnumInfos: file_temporal_server_api_common_v1_api_category_proto_enumTypes,

224 > MessageInfos: file_temporal_server_api_common_v1_api_category_proto_msgTypes,

225 > ExtensionInfos: file_temporal_server_api_common_v1_api_category_proto_extTypes,

226 > }.Build()

227 > File_temporal_server_api_common_v1_api_category_proto = out.File

228 > file_temporal_server_api_common_v1_api_category_proto_goTypes = nil

229 > file_temporal_server_api_common_v1_api_category_proto_depIdxs = nil

230 }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

1057 }

1058

1059 > func init() { file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() } request_response.pb.go

1060 > func file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() {

1061 > if File_temporal_server_chasm_lib_activity_proto_v1_request_response_proto != nil {

1062 > return

1063 > }

1064 > type x struct{}

1065 > out := protoimpl.TypeBuilder{

1066 > File: protoimpl.DescBuilder{

1067 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

1068 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDesc)),

1069 > NumEnums: 0,

1070 > NumMessages: 20,

1071 > NumExtensions: 0,

1072 > NumServices: 0,

1073 > },

1074 > GoTypes: file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_goTypes,

1075 > DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_depIdxs,

1076 > MessageInfos: file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes,

1077 > }.Build()

1078 > File_temporal_server_chasm_lib_activity_proto_v1_request_response_proto = out.File

1079 > file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_goTypes = nil

1080 > file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_depIdxs = nil

1081 }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

672 }

673

674 > func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init() } request_response.pb.go

675 > func file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init() {

676 > if File_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto != nil {

677 > return

678 > }

679 > type x struct{}

680 > out := protoimpl.TypeBuilder{

681 > File: protoimpl.DescBuilder{

682 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

683 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_rawDesc)),

684 > NumEnums: 0,

685 > NumMessages: 12,

686 > NumExtensions: 0,

687 > NumServices: 0,

688 > },

689 > GoTypes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_goTypes,

690 > DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_depIdxs,

691 > MessageInfos: file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_msgTypes,

692 > }.Build()

693 > File_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto = out.File

694 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_goTypes = nil

695 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_depIdxs = nil

696 }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

157 }

158

159 > func init() { file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init() } request_response.pb.go

160 > func file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init() {

161 > if File_temporal_server_chasm_lib_tests_proto_v1_request_response_proto != nil {

162 > return

163 > }

164 > type x struct{}

165 > out := protoimpl.TypeBuilder{

166 > File: protoimpl.DescBuilder{

167 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

168 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_rawDesc)),

169 > NumEnums: 0,

170 > NumMessages: 2,

171 > NumExtensions: 0,

172 > NumServices: 0,

173 > },

174 > GoTypes: file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_goTypes,

175 > DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_depIdxs,

176 > MessageInfos: file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_msgTypes,

177 > }.Build()

178 > File_temporal_server_chasm_lib_tests_proto_v1_request_response_proto = out.File

179 > file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_goTypes = nil

180 > file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_depIdxs = nil

181 }

go.temporal.io/server/common/future/future_impl.go 22 covered LOC · 3 ranges

Open complete file

29 )

30

31 > func NewFuture[T any]() *FutureImpl[T] { future_impl.go

32 > var value T

33 > return &FutureImpl[T]{

34 > status: pending,

35 > readyCh: make(chan struct{}),

36 >

37 > value: value,

38 > err: nil,

39 > }

40 > }

41

42 func (f *FutureImpl[T]) Get(

67 value T,

68 err error,

69 > ) { future_impl.go

70 > // cannot directly set status to `ready`, to prevent data race in case multiple `Get` occurs

71 > // instead set status to `setting` to prevent concurrent completion of this future

72 > if !atomic.CompareAndSwapInt32(

73 > &f.status,

74 > pending,

75 > setting,

76 > ) {

77 panic("future has already been completed")

78 }

79

80 > f.value = value future_impl.go

81 > f.err = err

82 > atomic.CompareAndSwapInt32(&f.status, setting, ready)

83 > close(f.readyCh)

84 }

85

go.temporal.io/server/api/persistence/v1/task_queues.pb.go 21 covered LOC · 2 ranges

Open complete file

899 }

900

901 > func init() { file_temporal_server_api_persistence_v1_task_queues_proto_init() } task_queues.pb.go

902 > func file_temporal_server_api_persistence_v1_task_queues_proto_init() {

903 > if File_temporal_server_api_persistence_v1_task_queues_proto != nil {

904 return

905 }

906 > type x struct{} task_queues.pb.go

907 > out := protoimpl.TypeBuilder{

908 > File: protoimpl.DescBuilder{

909 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

910 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_task_queues_proto_rawDesc), len(file_temporal_server_api_persistence_v1_task_queues_proto_rawDesc)),

911 > NumEnums: 1,

912 > NumMessages: 13,

913 > NumExtensions: 0,

914 > NumServices: 0,

915 > },

916 > GoTypes: file_temporal_server_api_persistence_v1_task_queues_proto_goTypes,

917 > DependencyIndexes: file_temporal_server_api_persistence_v1_task_queues_proto_depIdxs,

918 > EnumInfos: file_temporal_server_api_persistence_v1_task_queues_proto_enumTypes,

919 > MessageInfos: file_temporal_server_api_persistence_v1_task_queues_proto_msgTypes,

920 > }.Build()

921 > File_temporal_server_api_persistence_v1_task_queues_proto = out.File

922 > file_temporal_server_api_persistence_v1_task_queues_proto_goTypes = nil

923 > file_temporal_server_api_persistence_v1_task_queues_proto_depIdxs = nil

924 }

go.temporal.io/server/api/routing/v1/extension.pb.go 21 covered LOC · 2 ranges

Open complete file

144 }

145

146 > func init() { file_temporal_server_api_routing_v1_extension_proto_init() } extension.pb.go

147 > func file_temporal_server_api_routing_v1_extension_proto_init() {

148 > if File_temporal_server_api_routing_v1_extension_proto != nil {

149 return

150 }

151 > type x struct{} extension.pb.go

152 > out := protoimpl.TypeBuilder{

153 > File: protoimpl.DescBuilder{

154 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

155 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_routing_v1_extension_proto_rawDesc), len(file_temporal_server_api_routing_v1_extension_proto_rawDesc)),

156 > NumEnums: 0,

157 > NumMessages: 1,

158 > NumExtensions: 1,

159 > NumServices: 0,

160 > },

161 > GoTypes: file_temporal_server_api_routing_v1_extension_proto_goTypes,

162 > DependencyIndexes: file_temporal_server_api_routing_v1_extension_proto_depIdxs,

163 > MessageInfos: file_temporal_server_api_routing_v1_extension_proto_msgTypes,

164 > ExtensionInfos: file_temporal_server_api_routing_v1_extension_proto_extTypes,

165 > }.Build()

166 > File_temporal_server_api_routing_v1_extension_proto = out.File

167 > file_temporal_server_api_routing_v1_extension_proto_goTypes = nil

168 > file_temporal_server_api_routing_v1_extension_proto_depIdxs = nil

169 }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/tasks.pb.go 21 covered LOC · 2 ranges

Open complete file

495 }

496

497 > func init() { file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_init() } tasks.pb.go

498 > func file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_init() {

499 > if File_temporal_server_chasm_lib_activity_proto_v1_tasks_proto != nil {

500 return

501 }

502 > type x struct{} tasks.pb.go

503 > out := protoimpl.TypeBuilder{

504 > File: protoimpl.DescBuilder{

505 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

506 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_rawDesc)),

507 > NumEnums: 2,

508 > NumMessages: 5,

509 > NumExtensions: 0,

510 > NumServices: 0,

511 > },

512 > GoTypes: file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_goTypes,

513 > DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_depIdxs,

514 > EnumInfos: file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_enumTypes,

515 > MessageInfos: file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_msgTypes,

516 > }.Build()

517 > File_temporal_server_chasm_lib_activity_proto_v1_tasks_proto = out.File

518 > file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_goTypes = nil

519 > file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_depIdxs = nil

520 }

go.temporal.io/server/api/adminservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

273 }

274

275 > func init() { file_temporal_server_api_adminservice_v1_service_proto_init() } service.pb.go

276 > func file_temporal_server_api_adminservice_v1_service_proto_init() {

277 > if File_temporal_server_api_adminservice_v1_service_proto != nil {

278 return

279 }

280 > file_temporal_server_api_adminservice_v1_request_response_proto_init() service.pb.go

281 > type x struct{}

282 > out := protoimpl.TypeBuilder{

283 > File: protoimpl.DescBuilder{

284 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

285 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_adminservice_v1_service_proto_rawDesc), len(file_temporal_server_api_adminservice_v1_service_proto_rawDesc)),

286 > NumEnums: 0,

287 > NumMessages: 0,

288 > NumExtensions: 0,

289 > NumServices: 1,

290 > },

291 > GoTypes: file_temporal_server_api_adminservice_v1_service_proto_goTypes,

292 > DependencyIndexes: file_temporal_server_api_adminservice_v1_service_proto_depIdxs,

293 > }.Build()

294 > File_temporal_server_api_adminservice_v1_service_proto = out.File

295 > file_temporal_server_api_adminservice_v1_service_proto_goTypes = nil

296 > file_temporal_server_api_adminservice_v1_service_proto_depIdxs = nil

297 }

go.temporal.io/server/api/archiver/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

431 }

432

433 > func init() { file_temporal_server_api_archiver_v1_message_proto_init() } message.pb.go

434 > func file_temporal_server_api_archiver_v1_message_proto_init() {

435 > if File_temporal_server_api_archiver_v1_message_proto != nil {

436 return

437 }

438 > type x struct{} message.pb.go

439 > out := protoimpl.TypeBuilder{

440 > File: protoimpl.DescBuilder{

441 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

442 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_archiver_v1_message_proto_rawDesc), len(file_temporal_server_api_archiver_v1_message_proto_rawDesc)),

443 > NumEnums: 0,

444 > NumMessages: 4,

445 > NumExtensions: 0,

446 > NumServices: 0,

447 > },

448 > GoTypes: file_temporal_server_api_archiver_v1_message_proto_goTypes,

449 > DependencyIndexes: file_temporal_server_api_archiver_v1_message_proto_depIdxs,

450 > MessageInfos: file_temporal_server_api_archiver_v1_message_proto_msgTypes,

451 > }.Build()

452 > File_temporal_server_api_archiver_v1_message_proto = out.File

453 > file_temporal_server_api_archiver_v1_message_proto_goTypes = nil

454 > file_temporal_server_api_archiver_v1_message_proto_depIdxs = nil

455 }

go.temporal.io/server/api/chasm/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

206 }

207

208 > func init() { file_temporal_server_api_chasm_v1_message_proto_init() } message.pb.go

209 > func file_temporal_server_api_chasm_v1_message_proto_init() {

210 > if File_temporal_server_api_chasm_v1_message_proto != nil {

211 return

212 }

213 > type x struct{} message.pb.go

214 > out := protoimpl.TypeBuilder{

215 > File: protoimpl.DescBuilder{

216 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

217 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_chasm_v1_message_proto_rawDesc), len(file_temporal_server_api_chasm_v1_message_proto_rawDesc)),

218 > NumEnums: 0,

219 > NumMessages: 1,

220 > NumExtensions: 0,

221 > NumServices: 0,

222 > },

223 > GoTypes: file_temporal_server_api_chasm_v1_message_proto_goTypes,

224 > DependencyIndexes: file_temporal_server_api_chasm_v1_message_proto_depIdxs,

225 > MessageInfos: file_temporal_server_api_chasm_v1_message_proto_msgTypes,

226 > }.Build()

227 > File_temporal_server_api_chasm_v1_message_proto = out.File

228 > file_temporal_server_api_chasm_v1_message_proto_goTypes = nil

229 > file_temporal_server_api_chasm_v1_message_proto_depIdxs = nil

230 }

go.temporal.io/server/api/checksum/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

334 }

335

336 > func init() { file_temporal_server_api_checksum_v1_message_proto_init() } message.pb.go

337 > func file_temporal_server_api_checksum_v1_message_proto_init() {

338 > if File_temporal_server_api_checksum_v1_message_proto != nil {

339 return

340 }

341 > type x struct{} message.pb.go

342 > out := protoimpl.TypeBuilder{

343 > File: protoimpl.DescBuilder{

344 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

345 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_checksum_v1_message_proto_rawDesc), len(file_temporal_server_api_checksum_v1_message_proto_rawDesc)),

346 > NumEnums: 0,

347 > NumMessages: 1,

348 > NumExtensions: 0,

349 > NumServices: 0,

350 > },

351 > GoTypes: file_temporal_server_api_checksum_v1_message_proto_goTypes,

352 > DependencyIndexes: file_temporal_server_api_checksum_v1_message_proto_depIdxs,

353 > MessageInfos: file_temporal_server_api_checksum_v1_message_proto_msgTypes,

354 > }.Build()

355 > File_temporal_server_api_checksum_v1_message_proto = out.File

356 > file_temporal_server_api_checksum_v1_message_proto_goTypes = nil

357 > file_temporal_server_api_checksum_v1_message_proto_depIdxs = nil

358 }

go.temporal.io/server/api/cluster/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

342 }

343

344 > func init() { file_temporal_server_api_cluster_v1_message_proto_init() } message.pb.go

345 > func file_temporal_server_api_cluster_v1_message_proto_init() {

346 > if File_temporal_server_api_cluster_v1_message_proto != nil {

347 return

348 }

349 > type x struct{} message.pb.go

350 > out := protoimpl.TypeBuilder{

351 > File: protoimpl.DescBuilder{

352 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

353 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_cluster_v1_message_proto_rawDesc), len(file_temporal_server_api_cluster_v1_message_proto_rawDesc)),

354 > NumEnums: 0,

355 > NumMessages: 4,

356 > NumExtensions: 0,

357 > NumServices: 0,

358 > },

359 > GoTypes: file_temporal_server_api_cluster_v1_message_proto_goTypes,

360 > DependencyIndexes: file_temporal_server_api_cluster_v1_message_proto_depIdxs,

361 > MessageInfos: file_temporal_server_api_cluster_v1_message_proto_msgTypes,

362 > }.Build()

363 > File_temporal_server_api_cluster_v1_message_proto = out.File

364 > file_temporal_server_api_cluster_v1_message_proto_goTypes = nil

365 > file_temporal_server_api_cluster_v1_message_proto_depIdxs = nil

366 }

go.temporal.io/server/api/common/v1/dlq.pb.go 20 covered LOC · 2 ranges

Open complete file

295 }

296

297 > func init() { file_temporal_server_api_common_v1_dlq_proto_init() } dlq.pb.go

298 > func file_temporal_server_api_common_v1_dlq_proto_init() {

299 > if File_temporal_server_api_common_v1_dlq_proto != nil {

300 return

301 }

302 > type x struct{} dlq.pb.go

303 > out := protoimpl.TypeBuilder{

304 > File: protoimpl.DescBuilder{

305 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

306 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_common_v1_dlq_proto_rawDesc), len(file_temporal_server_api_common_v1_dlq_proto_rawDesc)),

307 > NumEnums: 0,

308 > NumMessages: 4,

309 > NumExtensions: 0,

310 > NumServices: 0,

311 > },

312 > GoTypes: file_temporal_server_api_common_v1_dlq_proto_goTypes,

313 > DependencyIndexes: file_temporal_server_api_common_v1_dlq_proto_depIdxs,

314 > MessageInfos: file_temporal_server_api_common_v1_dlq_proto_msgTypes,

315 > }.Build()

316 > File_temporal_server_api_common_v1_dlq_proto = out.File

317 > file_temporal_server_api_common_v1_dlq_proto_goTypes = nil

318 > file_temporal_server_api_common_v1_dlq_proto_depIdxs = nil

319 }

go.temporal.io/server/api/contextpropagation/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

109 }

110

111 > func init() { file_temporal_server_api_contextpropagation_v1_message_proto_init() } message.pb.go

112 > func file_temporal_server_api_contextpropagation_v1_message_proto_init() {

113 > if File_temporal_server_api_contextpropagation_v1_message_proto != nil {

114 return

115 }

116 > type x struct{} message.pb.go

117 > out := protoimpl.TypeBuilder{

118 > File: protoimpl.DescBuilder{

119 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

120 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_contextpropagation_v1_message_proto_rawDesc), len(file_temporal_server_api_contextpropagation_v1_message_proto_rawDesc)),

121 > NumEnums: 0,

122 > NumMessages: 2,

123 > NumExtensions: 0,

124 > NumServices: 0,

125 > },

126 > GoTypes: file_temporal_server_api_contextpropagation_v1_message_proto_goTypes,

127 > DependencyIndexes: file_temporal_server_api_contextpropagation_v1_message_proto_depIdxs,

128 > MessageInfos: file_temporal_server_api_contextpropagation_v1_message_proto_msgTypes,

129 > }.Build()

130 > File_temporal_server_api_contextpropagation_v1_message_proto = out.File

131 > file_temporal_server_api_contextpropagation_v1_message_proto_goTypes = nil

132 > file_temporal_server_api_contextpropagation_v1_message_proto_depIdxs = nil

133 }

go.temporal.io/server/api/deployment/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

4626 }

4627

4628 > func init() { file_temporal_server_api_deployment_v1_message_proto_init() } message.pb.go

4629 > func file_temporal_server_api_deployment_v1_message_proto_init() {

4630 > if File_temporal_server_api_deployment_v1_message_proto != nil {

4631 return

4632 }

4633 > type x struct{} message.pb.go

4634 > out := protoimpl.TypeBuilder{

4635 > File: protoimpl.DescBuilder{

4636 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

4637 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_deployment_v1_message_proto_rawDesc), len(file_temporal_server_api_deployment_v1_message_proto_rawDesc)),

4638 > NumEnums: 0,

4639 > NumMessages: 75,

4640 > NumExtensions: 0,

4641 > NumServices: 0,

4642 > },

4643 > GoTypes: file_temporal_server_api_deployment_v1_message_proto_goTypes,

4644 > DependencyIndexes: file_temporal_server_api_deployment_v1_message_proto_depIdxs,

4645 > MessageInfos: file_temporal_server_api_deployment_v1_message_proto_msgTypes,

4646 > }.Build()

4647 > File_temporal_server_api_deployment_v1_message_proto = out.File

4648 > file_temporal_server_api_deployment_v1_message_proto_goTypes = nil

4649 > file_temporal_server_api_deployment_v1_message_proto_depIdxs = nil

4650 }

go.temporal.io/server/api/enums/v1/cluster.pb.go 20 covered LOC · 2 ranges

Open complete file

209 }

210

211 > func init() { file_temporal_server_api_enums_v1_cluster_proto_init() } cluster.pb.go

212 > func file_temporal_server_api_enums_v1_cluster_proto_init() {

213 > if File_temporal_server_api_enums_v1_cluster_proto != nil {

214 return

215 }

216 > type x struct{} cluster.pb.go

217 > out := protoimpl.TypeBuilder{

218 > File: protoimpl.DescBuilder{

219 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

220 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_cluster_proto_rawDesc), len(file_temporal_server_api_enums_v1_cluster_proto_rawDesc)),

221 > NumEnums: 2,

222 > NumMessages: 0,

223 > NumExtensions: 0,

224 > NumServices: 0,

225 > },

226 > GoTypes: file_temporal_server_api_enums_v1_cluster_proto_goTypes,

227 > DependencyIndexes: file_temporal_server_api_enums_v1_cluster_proto_depIdxs,

228 > EnumInfos: file_temporal_server_api_enums_v1_cluster_proto_enumTypes,

229 > }.Build()

230 > File_temporal_server_api_enums_v1_cluster_proto = out.File

231 > file_temporal_server_api_enums_v1_cluster_proto_goTypes = nil

232 > file_temporal_server_api_enums_v1_cluster_proto_depIdxs = nil

233 }

go.temporal.io/server/api/enums/v1/dlq.pb.go 20 covered LOC · 2 ranges

Open complete file

187 }

188

189 > func init() { file_temporal_server_api_enums_v1_dlq_proto_init() } dlq.pb.go

190 > func file_temporal_server_api_enums_v1_dlq_proto_init() {

191 > if File_temporal_server_api_enums_v1_dlq_proto != nil {

192 return

193 }

194 > type x struct{} dlq.pb.go

195 > out := protoimpl.TypeBuilder{

196 > File: protoimpl.DescBuilder{

197 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

198 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_dlq_proto_rawDesc), len(file_temporal_server_api_enums_v1_dlq_proto_rawDesc)),

199 > NumEnums: 2,

200 > NumMessages: 0,

201 > NumExtensions: 0,

202 > NumServices: 0,

203 > },

204 > GoTypes: file_temporal_server_api_enums_v1_dlq_proto_goTypes,

205 > DependencyIndexes: file_temporal_server_api_enums_v1_dlq_proto_depIdxs,

206 > EnumInfos: file_temporal_server_api_enums_v1_dlq_proto_enumTypes,

207 > }.Build()

208 > File_temporal_server_api_enums_v1_dlq_proto = out.File

209 > file_temporal_server_api_enums_v1_dlq_proto_goTypes = nil

210 > file_temporal_server_api_enums_v1_dlq_proto_depIdxs = nil

211 }

go.temporal.io/server/api/enums/v1/fairness_state.pb.go 20 covered LOC · 2 ranges

Open complete file

123 }

124

125 > func init() { file_temporal_server_api_enums_v1_fairness_state_proto_init() } fairness_state.pb.go

126 > func file_temporal_server_api_enums_v1_fairness_state_proto_init() {

127 > if File_temporal_server_api_enums_v1_fairness_state_proto != nil {

128 return

129 }

130 > type x struct{} fairness_state.pb.go

131 > out := protoimpl.TypeBuilder{

132 > File: protoimpl.DescBuilder{

133 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

134 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc), len(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc)),

135 > NumEnums: 1,

136 > NumMessages: 0,

137 > NumExtensions: 0,

138 > NumServices: 0,

139 > },

140 > GoTypes: file_temporal_server_api_enums_v1_fairness_state_proto_goTypes,

141 > DependencyIndexes: file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs,

142 > EnumInfos: file_temporal_server_api_enums_v1_fairness_state_proto_enumTypes,

143 > }.Build()

144 > File_temporal_server_api_enums_v1_fairness_state_proto = out.File

145 > file_temporal_server_api_enums_v1_fairness_state_proto_goTypes = nil

146 > file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs = nil

147 }

go.temporal.io/server/api/enums/v1/replication.pb.go 20 covered LOC · 2 ranges

Open complete file

314 }

315

316 > func init() { file_temporal_server_api_enums_v1_replication_proto_init() } replication.pb.go

317 > func file_temporal_server_api_enums_v1_replication_proto_init() {

318 > if File_temporal_server_api_enums_v1_replication_proto != nil {

319 return

320 }

321 > type x struct{} replication.pb.go

322 > out := protoimpl.TypeBuilder{

323 > File: protoimpl.DescBuilder{

324 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

325 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_replication_proto_rawDesc), len(file_temporal_server_api_enums_v1_replication_proto_rawDesc)),

326 > NumEnums: 3,

327 > NumMessages: 0,

328 > NumExtensions: 0,

329 > NumServices: 0,

330 > },

331 > GoTypes: file_temporal_server_api_enums_v1_replication_proto_goTypes,

332 > DependencyIndexes: file_temporal_server_api_enums_v1_replication_proto_depIdxs,

333 > EnumInfos: file_temporal_server_api_enums_v1_replication_proto_enumTypes,

334 > }.Build()

335 > File_temporal_server_api_enums_v1_replication_proto = out.File

336 > file_temporal_server_api_enums_v1_replication_proto_goTypes = nil

337 > file_temporal_server_api_enums_v1_replication_proto_depIdxs = nil

338 }

go.temporal.io/server/api/errordetails/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

625 }

626

627 > func init() { file_temporal_server_api_errordetails_v1_message_proto_init() } message.pb.go

628 > func file_temporal_server_api_errordetails_v1_message_proto_init() {

629 > if File_temporal_server_api_errordetails_v1_message_proto != nil {

630 return

631 }

632 > type x struct{} message.pb.go

633 > out := protoimpl.TypeBuilder{

634 > File: protoimpl.DescBuilder{

635 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

636 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_errordetails_v1_message_proto_rawDesc), len(file_temporal_server_api_errordetails_v1_message_proto_rawDesc)),

637 > NumEnums: 0,

638 > NumMessages: 10,

639 > NumExtensions: 0,

640 > NumServices: 0,

641 > },

642 > GoTypes: file_temporal_server_api_errordetails_v1_message_proto_goTypes,

643 > DependencyIndexes: file_temporal_server_api_errordetails_v1_message_proto_depIdxs,

644 > MessageInfos: file_temporal_server_api_errordetails_v1_message_proto_msgTypes,

645 > }.Build()

646 > File_temporal_server_api_errordetails_v1_message_proto = out.File

647 > file_temporal_server_api_errordetails_v1_message_proto_goTypes = nil

648 > file_temporal_server_api_errordetails_v1_message_proto_depIdxs = nil

649 }

go.temporal.io/server/api/health/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

300 }

301

302 > func init() { file_temporal_server_api_health_v1_message_proto_init() } message.pb.go

303 > func file_temporal_server_api_health_v1_message_proto_init() {

304 > if File_temporal_server_api_health_v1_message_proto != nil {

305 return

306 }

307 > type x struct{} message.pb.go

308 > out := protoimpl.TypeBuilder{

309 > File: protoimpl.DescBuilder{

310 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

311 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_health_v1_message_proto_rawDesc), len(file_temporal_server_api_health_v1_message_proto_rawDesc)),

312 > NumEnums: 0,

313 > NumMessages: 3,

314 > NumExtensions: 0,

315 > NumServices: 0,

316 > },

317 > GoTypes: file_temporal_server_api_health_v1_message_proto_goTypes,

318 > DependencyIndexes: file_temporal_server_api_health_v1_message_proto_depIdxs,

319 > MessageInfos: file_temporal_server_api_health_v1_message_proto_msgTypes,

320 > }.Build()

321 > File_temporal_server_api_health_v1_message_proto = out.File

322 > file_temporal_server_api_health_v1_message_proto_goTypes = nil

323 > file_temporal_server_api_health_v1_message_proto_depIdxs = nil

324 }

go.temporal.io/server/api/historyservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

428 }

429

430 > func init() { file_temporal_server_api_historyservice_v1_service_proto_init() } service.pb.go

431 > func file_temporal_server_api_historyservice_v1_service_proto_init() {

432 > if File_temporal_server_api_historyservice_v1_service_proto != nil {

433 return

434 }

435 > file_temporal_server_api_historyservice_v1_request_response_proto_init() service.pb.go

436 > type x struct{}

437 > out := protoimpl.TypeBuilder{

438 > File: protoimpl.DescBuilder{

439 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

440 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_historyservice_v1_service_proto_rawDesc), len(file_temporal_server_api_historyservice_v1_service_proto_rawDesc)),

441 > NumEnums: 0,

442 > NumMessages: 0,

443 > NumExtensions: 0,

444 > NumServices: 1,

445 > },

446 > GoTypes: file_temporal_server_api_historyservice_v1_service_proto_goTypes,

447 > DependencyIndexes: file_temporal_server_api_historyservice_v1_service_proto_depIdxs,

448 > }.Build()

449 > File_temporal_server_api_historyservice_v1_service_proto = out.File

450 > file_temporal_server_api_historyservice_v1_service_proto_goTypes = nil

451 > file_temporal_server_api_historyservice_v1_service_proto_depIdxs = nil

452 }

go.temporal.io/server/api/matchingservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

250 }

251

252 > func init() { file_temporal_server_api_matchingservice_v1_service_proto_init() } service.pb.go

253 > func file_temporal_server_api_matchingservice_v1_service_proto_init() {

254 > if File_temporal_server_api_matchingservice_v1_service_proto != nil {

255 return

256 }

257 > file_temporal_server_api_matchingservice_v1_request_response_proto_init() service.pb.go

258 > type x struct{}

259 > out := protoimpl.TypeBuilder{

260 > File: protoimpl.DescBuilder{

261 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

262 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_matchingservice_v1_service_proto_rawDesc), len(file_temporal_server_api_matchingservice_v1_service_proto_rawDesc)),

263 > NumEnums: 0,

264 > NumMessages: 0,

265 > NumExtensions: 0,

266 > NumServices: 1,

267 > },

268 > GoTypes: file_temporal_server_api_matchingservice_v1_service_proto_goTypes,

269 > DependencyIndexes: file_temporal_server_api_matchingservice_v1_service_proto_depIdxs,

270 > }.Build()

271 > File_temporal_server_api_matchingservice_v1_service_proto = out.File

272 > file_temporal_server_api_matchingservice_v1_service_proto_goTypes = nil

273 > file_temporal_server_api_matchingservice_v1_service_proto_depIdxs = nil

274 }

go.temporal.io/server/api/metrics/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

104 }

105

106 > func init() { file_temporal_server_api_metrics_v1_message_proto_init() } message.pb.go

107 > func file_temporal_server_api_metrics_v1_message_proto_init() {

108 > if File_temporal_server_api_metrics_v1_message_proto != nil {

109 return

110 }

111 > type x struct{} message.pb.go

112 > out := protoimpl.TypeBuilder{

113 > File: protoimpl.DescBuilder{

114 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

115 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_metrics_v1_message_proto_rawDesc), len(file_temporal_server_api_metrics_v1_message_proto_rawDesc)),

116 > NumEnums: 0,

117 > NumMessages: 2,

118 > NumExtensions: 0,

119 > NumServices: 0,

120 > },

121 > GoTypes: file_temporal_server_api_metrics_v1_message_proto_goTypes,

122 > DependencyIndexes: file_temporal_server_api_metrics_v1_message_proto_depIdxs,

123 > MessageInfos: file_temporal_server_api_metrics_v1_message_proto_msgTypes,

124 > }.Build()

125 > File_temporal_server_api_metrics_v1_message_proto = out.File

126 > file_temporal_server_api_metrics_v1_message_proto_goTypes = nil

127 > file_temporal_server_api_metrics_v1_message_proto_depIdxs = nil

128 }

go.temporal.io/server/api/namespace/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

114 }

115

116 > func init() { file_temporal_server_api_namespace_v1_message_proto_init() } message.pb.go

117 > func file_temporal_server_api_namespace_v1_message_proto_init() {

118 > if File_temporal_server_api_namespace_v1_message_proto != nil {

119 return

120 }

121 > type x struct{} message.pb.go

122 > out := protoimpl.TypeBuilder{

123 > File: protoimpl.DescBuilder{

124 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

125 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_namespace_v1_message_proto_rawDesc), len(file_temporal_server_api_namespace_v1_message_proto_rawDesc)),

126 > NumEnums: 0,

127 > NumMessages: 1,

128 > NumExtensions: 0,

129 > NumServices: 0,

130 > },

131 > GoTypes: file_temporal_server_api_namespace_v1_message_proto_goTypes,

132 > DependencyIndexes: file_temporal_server_api_namespace_v1_message_proto_depIdxs,

133 > MessageInfos: file_temporal_server_api_namespace_v1_message_proto_msgTypes,

134 > }.Build()

135 > File_temporal_server_api_namespace_v1_message_proto = out.File

136 > file_temporal_server_api_namespace_v1_message_proto_goTypes = nil

137 > file_temporal_server_api_namespace_v1_message_proto_depIdxs = nil

138 }

go.temporal.io/server/api/persistence/v1/chasm_visibility.pb.go 20 covered LOC · 2 ranges

Open complete file

146 }

147

148 > func init() { file_temporal_server_api_persistence_v1_chasm_visibility_proto_init() } chasm_visibility.pb.go

149 > func file_temporal_server_api_persistence_v1_chasm_visibility_proto_init() {

150 > if File_temporal_server_api_persistence_v1_chasm_visibility_proto != nil {

151 return

152 }

153 > type x struct{} chasm_visibility.pb.go

154 > out := protoimpl.TypeBuilder{

155 > File: protoimpl.DescBuilder{

156 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

157 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_chasm_visibility_proto_rawDesc), len(file_temporal_server_api_persistence_v1_chasm_visibility_proto_rawDesc)),

158 > NumEnums: 0,

159 > NumMessages: 2,

160 > NumExtensions: 0,

161 > NumServices: 0,

162 > },

163 > GoTypes: file_temporal_server_api_persistence_v1_chasm_visibility_proto_goTypes,

164 > DependencyIndexes: file_temporal_server_api_persistence_v1_chasm_visibility_proto_depIdxs,

165 > MessageInfos: file_temporal_server_api_persistence_v1_chasm_visibility_proto_msgTypes,

166 > }.Build()

167 > File_temporal_server_api_persistence_v1_chasm_visibility_proto = out.File

168 > file_temporal_server_api_persistence_v1_chasm_visibility_proto_goTypes = nil

169 > file_temporal_server_api_persistence_v1_chasm_visibility_proto_depIdxs = nil

170 }

go.temporal.io/server/api/persistence/v1/cluster_metadata.pb.go 20 covered LOC · 2 ranges

Open complete file

289 }

290

291 > func init() { file_temporal_server_api_persistence_v1_cluster_metadata_proto_init() } cluster_metadata.pb.go

292 > func file_temporal_server_api_persistence_v1_cluster_metadata_proto_init() {

293 > if File_temporal_server_api_persistence_v1_cluster_metadata_proto != nil {

294 return

295 }

296 > type x struct{} cluster_metadata.pb.go

297 > out := protoimpl.TypeBuilder{

298 > File: protoimpl.DescBuilder{

299 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

300 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_cluster_metadata_proto_rawDesc), len(file_temporal_server_api_persistence_v1_cluster_metadata_proto_rawDesc)),

301 > NumEnums: 0,

302 > NumMessages: 5,

303 > NumExtensions: 0,

304 > NumServices: 0,

305 > },

306 > GoTypes: file_temporal_server_api_persistence_v1_cluster_metadata_proto_goTypes,

307 > DependencyIndexes: file_temporal_server_api_persistence_v1_cluster_metadata_proto_depIdxs,

308 > MessageInfos: file_temporal_server_api_persistence_v1_cluster_metadata_proto_msgTypes,

309 > }.Build()

310 > File_temporal_server_api_persistence_v1_cluster_metadata_proto = out.File

311 > file_temporal_server_api_persistence_v1_cluster_metadata_proto_goTypes = nil

312 > file_temporal_server_api_persistence_v1_cluster_metadata_proto_depIdxs = nil

313 }

go.temporal.io/server/api/persistence/v1/history_tree.pb.go 20 covered LOC · 2 ranges

Open complete file

274 }

275

276 > func init() { file_temporal_server_api_persistence_v1_history_tree_proto_init() } history_tree.pb.go

277 > func file_temporal_server_api_persistence_v1_history_tree_proto_init() {

278 > if File_temporal_server_api_persistence_v1_history_tree_proto != nil {

279 return

280 }

281 > type x struct{} history_tree.pb.go

282 > out := protoimpl.TypeBuilder{

283 > File: protoimpl.DescBuilder{

284 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

285 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_history_tree_proto_rawDesc), len(file_temporal_server_api_persistence_v1_history_tree_proto_rawDesc)),

286 > NumEnums: 0,

287 > NumMessages: 3,

288 > NumExtensions: 0,

289 > NumServices: 0,

290 > },

291 > GoTypes: file_temporal_server_api_persistence_v1_history_tree_proto_goTypes,

292 > DependencyIndexes: file_temporal_server_api_persistence_v1_history_tree_proto_depIdxs,

293 > MessageInfos: file_temporal_server_api_persistence_v1_history_tree_proto_msgTypes,

294 > }.Build()

295 > File_temporal_server_api_persistence_v1_history_tree_proto = out.File

296 > file_temporal_server_api_persistence_v1_history_tree_proto_goTypes = nil

297 > file_temporal_server_api_persistence_v1_history_tree_proto_depIdxs = nil

298 }

go.temporal.io/server/api/persistence/v1/namespaces.pb.go 20 covered LOC · 2 ranges

Open complete file

536 }

537

538 > func init() { file_temporal_server_api_persistence_v1_namespaces_proto_init() } namespaces.pb.go

539 > func file_temporal_server_api_persistence_v1_namespaces_proto_init() {

540 > if File_temporal_server_api_persistence_v1_namespaces_proto != nil {

541 return

542 }

543 > type x struct{} namespaces.pb.go

544 > out := protoimpl.TypeBuilder{

545 > File: protoimpl.DescBuilder{

546 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

547 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_namespaces_proto_rawDesc), len(file_temporal_server_api_persistence_v1_namespaces_proto_rawDesc)),

548 > NumEnums: 0,

549 > NumMessages: 8,

550 > NumExtensions: 0,

551 > NumServices: 0,

552 > },

553 > GoTypes: file_temporal_server_api_persistence_v1_namespaces_proto_goTypes,

554 > DependencyIndexes: file_temporal_server_api_persistence_v1_namespaces_proto_depIdxs,

555 > MessageInfos: file_temporal_server_api_persistence_v1_namespaces_proto_msgTypes,

556 > }.Build()

557 > File_temporal_server_api_persistence_v1_namespaces_proto = out.File

558 > file_temporal_server_api_persistence_v1_namespaces_proto_goTypes = nil

559 > file_temporal_server_api_persistence_v1_namespaces_proto_depIdxs = nil

560 }

go.temporal.io/server/api/persistence/v1/queue_metadata.pb.go 20 covered LOC · 2 ranges

Open complete file

105 }

106

107 > func init() { file_temporal_server_api_persistence_v1_queue_metadata_proto_init() } queue_metadata.pb.go

108 > func file_temporal_server_api_persistence_v1_queue_metadata_proto_init() {

109 > if File_temporal_server_api_persistence_v1_queue_metadata_proto != nil {

110 return

111 }

112 > type x struct{} queue_metadata.pb.go

113 > out := protoimpl.TypeBuilder{

114 > File: protoimpl.DescBuilder{

115 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

116 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_queue_metadata_proto_rawDesc), len(file_temporal_server_api_persistence_v1_queue_metadata_proto_rawDesc)),

117 > NumEnums: 0,

118 > NumMessages: 2,

119 > NumExtensions: 0,

120 > NumServices: 0,

121 > },

122 > GoTypes: file_temporal_server_api_persistence_v1_queue_metadata_proto_goTypes,

123 > DependencyIndexes: file_temporal_server_api_persistence_v1_queue_metadata_proto_depIdxs,

124 > MessageInfos: file_temporal_server_api_persistence_v1_queue_metadata_proto_msgTypes,

125 > }.Build()

126 > File_temporal_server_api_persistence_v1_queue_metadata_proto = out.File

127 > file_temporal_server_api_persistence_v1_queue_metadata_proto_goTypes = nil

128 > file_temporal_server_api_persistence_v1_queue_metadata_proto_depIdxs = nil

129 }

go.temporal.io/server/api/persistence/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

846 }

847

848 > func init() { file_temporal_server_api_persistence_v1_tasks_proto_init() } tasks.pb.go

849 > func file_temporal_server_api_persistence_v1_tasks_proto_init() {

850 > if File_temporal_server_api_persistence_v1_tasks_proto != nil {

851 return

852 }

853 > type x struct{} tasks.pb.go

854 > out := protoimpl.TypeBuilder{

855 > File: protoimpl.DescBuilder{

856 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

857 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_tasks_proto_rawDesc), len(file_temporal_server_api_persistence_v1_tasks_proto_rawDesc)),

858 > NumEnums: 0,

859 > NumMessages: 8,

860 > NumExtensions: 0,

861 > NumServices: 0,

862 > },

863 > GoTypes: file_temporal_server_api_persistence_v1_tasks_proto_goTypes,

864 > DependencyIndexes: file_temporal_server_api_persistence_v1_tasks_proto_depIdxs,

865 > MessageInfos: file_temporal_server_api_persistence_v1_tasks_proto_msgTypes,

866 > }.Build()

867 > File_temporal_server_api_persistence_v1_tasks_proto = out.File

868 > file_temporal_server_api_persistence_v1_tasks_proto_goTypes = nil

869 > file_temporal_server_api_persistence_v1_tasks_proto_depIdxs = nil

870 }

go.temporal.io/server/api/token/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

785 }

786

787 > func init() { file_temporal_server_api_token_v1_message_proto_init() } message.pb.go

788 > func file_temporal_server_api_token_v1_message_proto_init() {

789 > if File_temporal_server_api_token_v1_message_proto != nil {

790 return

791 }

792 > type x struct{} message.pb.go

793 > out := protoimpl.TypeBuilder{

794 > File: protoimpl.DescBuilder{

795 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

796 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_token_v1_message_proto_rawDesc), len(file_temporal_server_api_token_v1_message_proto_rawDesc)),

797 > NumEnums: 0,

798 > NumMessages: 7,

799 > NumExtensions: 0,

800 > NumServices: 0,

801 > },

802 > GoTypes: file_temporal_server_api_token_v1_message_proto_goTypes,

803 > DependencyIndexes: file_temporal_server_api_token_v1_message_proto_depIdxs,

804 > MessageInfos: file_temporal_server_api_token_v1_message_proto_msgTypes,

805 > }.Build()

806 > File_temporal_server_api_token_v1_message_proto = out.File

807 > file_temporal_server_api_token_v1_message_proto_goTypes = nil

808 > file_temporal_server_api_token_v1_message_proto_depIdxs = nil

809 }

go.temporal.io/server/api/visibilityservice/v1/request_response.pb.go 20 covered LOC · 2 ranges

Open complete file

402 }

403

404 > func init() { file_temporal_server_api_visibilityservice_v1_request_response_proto_init() } request_response.pb.go

405 > func file_temporal_server_api_visibilityservice_v1_request_response_proto_init() {

406 > if File_temporal_server_api_visibilityservice_v1_request_response_proto != nil {

407 return

408 }

409 > type x struct{} request_response.pb.go

410 > out := protoimpl.TypeBuilder{

411 > File: protoimpl.DescBuilder{

412 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

413 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_visibilityservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_visibilityservice_v1_request_response_proto_rawDesc)),

414 > NumEnums: 0,

415 > NumMessages: 5,

416 > NumExtensions: 0,

417 > NumServices: 0,

418 > },

419 > GoTypes: file_temporal_server_api_visibilityservice_v1_request_response_proto_goTypes,

420 > DependencyIndexes: file_temporal_server_api_visibilityservice_v1_request_response_proto_depIdxs,

421 > MessageInfos: file_temporal_server_api_visibilityservice_v1_request_response_proto_msgTypes,

422 > }.Build()

423 > File_temporal_server_api_visibilityservice_v1_request_response_proto = out.File

424 > file_temporal_server_api_visibilityservice_v1_request_response_proto_goTypes = nil

425 > file_temporal_server_api_visibilityservice_v1_request_response_proto_depIdxs = nil

426 }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

91 }

92

93 > func init() { file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() } service.pb.go

94 > func file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() {

95 > if File_temporal_server_chasm_lib_activity_proto_v1_service_proto != nil {

96 return

97 }

98 > file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() service.pb.go

99 > type x struct{}

100 > out := protoimpl.TypeBuilder{

101 > File: protoimpl.DescBuilder{

102 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

103 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc)),

104 > NumEnums: 0,

105 > NumMessages: 0,

106 > NumExtensions: 0,

107 > NumServices: 1,

108 > },

109 > GoTypes: file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes,

110 > DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs,

111 > }.Build()

112 > File_temporal_server_chasm_lib_activity_proto_v1_service_proto = out.File

113 > file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes = nil

114 > file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs = nil

115 }

go.temporal.io/server/chasm/lib/callback/gen/callbackpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

148 }

149

150 > func init() { file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() } tasks.pb.go

151 > func file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() {

152 > if File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto != nil {

153 return

154 }

155 > type x struct{} tasks.pb.go

156 > out := protoimpl.TypeBuilder{

157 > File: protoimpl.DescBuilder{

158 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

159 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc)),

160 > NumEnums: 0,

161 > NumMessages: 2,

162 > NumExtensions: 0,

163 > NumServices: 0,

164 > },

165 > GoTypes: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes,

166 > DependencyIndexes: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs,

167 > MessageInfos: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_msgTypes,

168 > }.Build()

169 > File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto = out.File

170 > file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes = nil

171 > file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs = nil

172 }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

71 }

72

73 > func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() } service.pb.go

74 > func file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() {

75 > if File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto != nil {

76 return

77 }

78 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init() service.pb.go

79 > type x struct{}

80 > out := protoimpl.TypeBuilder{

81 > File: protoimpl.DescBuilder{

82 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

83 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc)),

84 > NumEnums: 0,

85 > NumMessages: 0,

86 > NumExtensions: 0,

87 > NumServices: 1,

88 > },

89 > GoTypes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes,

90 > DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs,

91 > }.Build()

92 > File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto = out.File

93 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes = nil

94 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs = nil

95 }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

354 }

355

356 > func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() } tasks.pb.go

357 > func file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() {

358 > if File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto != nil {

359 return

360 }

361 > type x struct{} tasks.pb.go

362 > out := protoimpl.TypeBuilder{

363 > File: protoimpl.DescBuilder{

364 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

365 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc)),

366 > NumEnums: 0,

367 > NumMessages: 7,

368 > NumExtensions: 0,

369 > NumServices: 0,

370 > },

371 > GoTypes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes,

372 > DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs,

373 > MessageInfos: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_msgTypes,

374 > }.Build()

375 > File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto = out.File

376 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes = nil

377 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs = nil

378 }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

86 }

87

88 > func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_init() } service.pb.go

89 > func file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_init() {

90 > if File_temporal_server_chasm_lib_scheduler_proto_v1_service_proto != nil {

91 return

92 }

93 > file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init() service.pb.go

94 > type x struct{}

95 > out := protoimpl.TypeBuilder{

96 > File: protoimpl.DescBuilder{

97 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

98 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_rawDesc)),

99 > NumEnums: 0,

100 > NumMessages: 0,

101 > NumExtensions: 0,

102 > NumServices: 1,

103 > },

104 > GoTypes: file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_goTypes,

105 > DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_depIdxs,

106 > }.Build()

107 > File_temporal_server_chasm_lib_scheduler_proto_v1_service_proto = out.File

108 > file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_goTypes = nil

109 > file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_depIdxs = nil

110 }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

343 }

344

345 > func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_init() } tasks.pb.go

346 > func file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_init() {

347 > if File_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto != nil {

348 return

349 }

350 > type x struct{} tasks.pb.go

351 > out := protoimpl.TypeBuilder{

352 > File: protoimpl.DescBuilder{

353 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

354 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_rawDesc)),

355 > NumEnums: 0,

356 > NumMessages: 7,

357 > NumExtensions: 0,

358 > NumServices: 0,

359 > },

360 > GoTypes: file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_goTypes,

361 > DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_depIdxs,

362 > MessageInfos: file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_msgTypes,

363 > }.Build()

364 > File_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto = out.File

365 > file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_goTypes = nil

366 > file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_depIdxs = nil

367 }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

242 }

243

244 > func init() { file_temporal_server_chasm_lib_tests_proto_v1_message_proto_init() } message.pb.go

245 > func file_temporal_server_chasm_lib_tests_proto_v1_message_proto_init() {

246 > if File_temporal_server_chasm_lib_tests_proto_v1_message_proto != nil {

247 return

248 }

249 > type x struct{} message.pb.go

250 > out := protoimpl.TypeBuilder{

251 > File: protoimpl.DescBuilder{

252 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

253 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_message_proto_rawDesc)),

254 > NumEnums: 0,

255 > NumMessages: 4,

256 > NumExtensions: 0,

257 > NumServices: 0,

258 > },

259 > GoTypes: file_temporal_server_chasm_lib_tests_proto_v1_message_proto_goTypes,

260 > DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_message_proto_depIdxs,

261 > MessageInfos: file_temporal_server_chasm_lib_tests_proto_v1_message_proto_msgTypes,

262 > }.Build()

263 > File_temporal_server_chasm_lib_tests_proto_v1_message_proto = out.File

264 > file_temporal_server_chasm_lib_tests_proto_v1_message_proto_goTypes = nil

265 > file_temporal_server_chasm_lib_tests_proto_v1_message_proto_depIdxs = nil

266 }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

46 }

47

48 > func init() { file_temporal_server_chasm_lib_tests_proto_v1_service_proto_init() } service.pb.go

49 > func file_temporal_server_chasm_lib_tests_proto_v1_service_proto_init() {

50 > if File_temporal_server_chasm_lib_tests_proto_v1_service_proto != nil {

51 return

52 }

53 > file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init() service.pb.go

54 > type x struct{}

55 > out := protoimpl.TypeBuilder{

56 > File: protoimpl.DescBuilder{

57 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

58 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_service_proto_rawDesc)),

59 > NumEnums: 0,

60 > NumMessages: 0,

61 > NumExtensions: 0,

62 > NumServices: 1,

63 > },

64 > GoTypes: file_temporal_server_chasm_lib_tests_proto_v1_service_proto_goTypes,

65 > DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_service_proto_depIdxs,

66 > }.Build()

67 > File_temporal_server_chasm_lib_tests_proto_v1_service_proto = out.File

68 > file_temporal_server_chasm_lib_tests_proto_v1_service_proto_goTypes = nil

69 > file_temporal_server_chasm_lib_tests_proto_v1_service_proto_depIdxs = nil

70 }

go.temporal.io/server/chasm/lib/workflow/gen/workflowpb/v1/state.pb.go 20 covered LOC · 2 ranges

Open complete file

211 }

212

213 > func init() { file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_init() } state.pb.go

214 > func file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_init() {

215 > if File_temporal_server_chasm_lib_workflow_proto_v1_state_proto != nil {

216 return

217 }

218 > type x struct{} state.pb.go

219 > out := protoimpl.TypeBuilder{

220 > File: protoimpl.DescBuilder{

221 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

222 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_rawDesc), len(file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_rawDesc)),

223 > NumEnums: 0,

224 > NumMessages: 3,

225 > NumExtensions: 0,

226 > NumServices: 0,

227 > },

228 > GoTypes: file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_goTypes,

229 > DependencyIndexes: file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_depIdxs,

230 > MessageInfos: file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_msgTypes,

231 > }.Build()

232 > File_temporal_server_chasm_lib_workflow_proto_v1_state_proto = out.File

233 > file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_goTypes = nil

234 > file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_depIdxs = nil

235 }

go.temporal.io/server/chasm/lib/workflow/gen/workflowpb/v1/update_state.pb.go 20 covered LOC · 2 ranges

Open complete file

113 }

114

115 > func init() { file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_init() } update_state.pb.go

116 > func file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_init() {

117 > if File_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto != nil {

118 return

119 }

120 > type x struct{} update_state.pb.go

121 > out := protoimpl.TypeBuilder{

122 > File: protoimpl.DescBuilder{

123 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

124 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_rawDesc), len(file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_rawDesc)),

125 > NumEnums: 0,

126 > NumMessages: 1,

127 > NumExtensions: 0,

128 > NumServices: 0,

129 > },

130 > GoTypes: file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_goTypes,

131 > DependencyIndexes: file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_depIdxs,

132 > MessageInfos: file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_msgTypes,

133 > }.Build()

134 > File_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto = out.File

135 > file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_goTypes = nil

136 > file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_depIdxs = nil

137 }

go.temporal.io/server/common/primitives/uuid.go 20 covered LOC · 5 ranges

Open complete file

68

69 // NewUUID generates a new random UUID

70 > func NewUUID() UUID { uuid.go

71 > u, err := guuid.NewV7()

72 > if err != nil {

73 // Should never happen, but this matches the behavior of google/uuid.NewRandom

74 return nil

75 }

76 > return u[:] uuid.go

77 }

78

91 // String returns the 36 byte hexstring representation of this uuid

92 // return empty string if this uuid is nil

93 > func (u UUID) String() string { uuid.go

94 > if len(u) != 16 {

95 return ""

96 }

97 > var buf [36]byte uuid.go

98 > u.encodeHex(buf[:])

99 > return string(buf[:])

100 }

101

140 }

141

142 > func (u UUID) encodeHex(dst []byte) { uuid.go

143 > hex.Encode(dst, u[:4])

144 > dst[8] = '-'

145 > hex.Encode(dst[9:13], u[4:6])

146 > dst[13] = '-'

147 > hex.Encode(dst[14:18], u[6:8])

148 > dst[18] = '-'

149 > hex.Encode(dst[19:23], u[8:10])

150 > dst[23] = '-'

151 > hex.Encode(dst[24:], u[10:])

152 > }

go.temporal.io/server/common/util/wildcard.go 20 covered LOC · 7 ranges

Open complete file

18 // WildCardStringToRegexps converts a given slices of string patterns to a slice of regular expressions matching

19 // wildcards (*) with any substring.

20 > func WildCardStringsToRegexp(patterns []string) (*regexp.Regexp, error) { wildcard.go

21 > var result strings.Builder

22 > result.WriteRune('^')

23 > for i, pattern := range patterns {

24 > result.WriteRune('(')

25 > first := true

26 > for literal := range strings.SplitSeq(pattern, "*") {

27 > if !first {

28 // Replace * with .*

29 result.WriteString(".*")

30 }

31 > result.WriteString(regexp.QuoteMeta(literal)) wildcard.go

32 > first = false

33 }

34 > result.WriteRune(')') wildcard.go

35 > if i < len(patterns)-1 {

36 > result.WriteRune('|') wildcard.go

37 > }

38 }

39 > result.WriteRune('$') wildcard.go

40 > return regexp.Compile(result.String())

41 }

42

43 // MustWildCardStringsToRegexp is like WildCardStringsToRegexp but panics on error.

44 > func MustWildCardStringsToRegexp(patterns []string) *regexp.Regexp { wildcard.go

45 > re, err := WildCardStringsToRegexp(patterns)

46 > if err != nil {

47 panic(err) //nolint:forbidigo // Must* functions conventionally panic on error.

48 }

49 > return re wildcard.go

50 }

go.temporal.io/server/service/history/hsm/registry.go 19 covered LOC · 4 ranges

Open complete file

47

48 // NewRegistry creates a new [Registry].

49 > func NewRegistry() *Registry { registry.go

50 > return &Registry{

51 > machines: make(map[string]StateMachineDefinition),

52 > tasks: make(map[string]TaskSerializer),

53 > immediateExecutors: make(map[string]any),

54 > timerExecutors: make(map[string]any),

55 > remoteExecutors: make(map[string]remoteMethodDefinition),

56 > events: make(map[enumspb.EventType]EventDefinition),

57 > }

58 > }

59

60 // RegisterMachine registers a [StateMachineDefinition] by its type.

61 // Returns an [ErrDuplicateRegistration] if the state machine type has already been registered.

62 > func (r *Registry) RegisterMachine(sm StateMachineDefinition) error { registry.go

63 > t := sm.Type()

64 > if existing, ok := r.machines[t]; ok {

65 return fmt.Errorf("%w: state machine already registered for %v - %v", ErrDuplicateRegistration, sm.Type(), existing.Type())

66 }

67 > r.machines[t] = sm registry.go

68 > return nil

69 }

70

71 // Machine returns a [StateMachineDefinition] for a given type and a boolean indicating whether it was found.

72 > func (r *Registry) Machine(t string) (def StateMachineDefinition, ok bool) { registry.go

73 > def, ok = r.machines[t]

74 > return

75 > }

76

77 // RegisterTaskSerializer registers a [TaskSerializer] for a given type.

go.temporal.io/server/service/history/shard/controller_mock.go 19 covered LOC · 4 ranges

Open complete file

33

34 // NewMockController creates a new mock instance.

35 > func NewMockController(ctrl *gomock.Controller) *MockController { controller_mock.go

36 > mock := &MockController{ctrl: ctrl}

37 > mock.recorder = &MockControllerMockRecorder{mock}

38 > return mock

39 > }

40

41 // EXPECT returns an object that allows the caller to indicate expected use.

42 > func (m *MockController) EXPECT() *MockControllerMockRecorder { controller_mock.go

43 > return m.recorder

44 > }

45

46 // CloseShardByID mocks base method.

71

72 // GetShardByID mocks base method.

73 > func (m *MockController) GetShardByID(shardID int32) (interfaces.ShardContext, error) { controller_mock.go

74 > m.ctrl.T.Helper()

75 > ret := m.ctrl.Call(m, "GetShardByID", shardID)

76 > ret0, _ := ret[0].(interfaces.ShardContext)

77 > ret1, _ := ret[1].(error)

78 > return ret0, ret1

79 > }

80

81 // GetShardByID indicates an expected call of GetShardByID.

82 > func (mr *MockControllerMockRecorder) GetShardByID(shardID any) *gomock.Call { controller_mock.go

83 > mr.mock.ctrl.T.Helper()

84 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShardByID", reflect.TypeOf((*MockController)(nil).GetShardByID), shardID)

85 > }

86

87 // GetShardByNamespaceWorkflow mocks base method.

go.temporal.io/server/service/history/workflow/task_generator_provider.go 19 covered LOC · 4 ranges

Open complete file

23 )

24

25 > func init() { task_generator_provider.go

26 > var defaultProvider TaskGeneratorProvider = new(taskGeneratorProviderImpl)

27 > populateTaskGeneratorProvider(defaultProvider)

28 > }

29

30 > func populateTaskGeneratorProvider(provider TaskGeneratorProvider) { task_generator_provider.go

31 > _taskGeneratorProvider.Store(&provider)

32 > }

33

34 > func GetTaskGeneratorProvider() TaskGeneratorProvider { task_generator_provider.go

35 > return *_taskGeneratorProvider.Load()

36 > }

37

38 func (p *taskGeneratorProviderImpl) NewTaskGenerator(

39 shard historyi.ShardContext,

40 mutableState historyi.MutableState,

41 > ) TaskGenerator { task_generator_provider.go

42 > return NewTaskGenerator(

43 > shard.GetNamespaceRegistry(),

44 > mutableState,

45 > shard.GetConfig(),

46 > shard.GetArchivalMetadata(),

47 > shard.GetLogger(),

48 > )

49 > }

go.temporal.io/server/common/metrics/tags.go 18 covered LOC · 8 ranges

Open complete file

101 // dual emit the metric with the all tag. If a blank namespace is provided then

102 // this converts that to an unknown namespace.

103 > func NamespaceTag(value string) Tag { tags.go

104 > if len(value) == 0 {

105 value = unknownValue

106 }

107 > return Tag{Key: namespace, Value: value} tags.go

108 }

109

110 // NamespaceIDTag returns a new namespace ID tag.

111 > func NamespaceIDTag(value string) Tag { tags.go

112 > if len(value) == 0 {

113 value = unknownValue

114 }

115 > return Tag{Key: namespaceID, Value: value} tags.go

116 }

117

447 }

448

449 > func ServiceNameTag(value primitives.ServiceName) Tag { tags.go

450 > return Tag{Key: serviceName, Value: string(value)}

451 > }

452

453 func ActionType(value string) Tag {

455 }

456

457 > func OperationTag(value string) Tag { tags.go

458 > return Tag{Key: OperationTagName, Value: value}

459 > }

460

461 func StringTag(key string, value string) Tag {

463 }

464

465 > func CacheTypeTag(value string) Tag { tags.go

466 > return Tag{Key: CacheTypeTagName, Value: value}

467 > }

468

469 > func PriorityTag(value locks.Priority) Tag { tags.go

470 > return Tag{Key: PriorityTagName, Value: strconv.Itoa(int(value))}

471 > }

472

473 // ReasonString is just a string but the special type is defined here to remind callers of ReasonTag to limit the

go.temporal.io/server/service/history/tasks/task_category_registry.go 18 covered LOC · 4 ranges

Open complete file

26 // each entry point that uses it. Essentially, get it from the dependency graph instead of calling this method, unless

27 // you're in a test.

28 > func NewDefaultTaskCategoryRegistry() *MutableTaskCategoryRegistry { task_category_registry.go

29 > return &MutableTaskCategoryRegistry{

30 > categories: map[int]Category{

31 > CategoryTransfer.ID(): CategoryTransfer,

32 > CategoryTimer.ID(): CategoryTimer,

33 > CategoryVisibility.ID(): CategoryVisibility,

34 > CategoryReplication.ID(): CategoryReplication,

35 > CategoryMemoryTimer.ID(): CategoryMemoryTimer,

36 > CategoryOutbound.ID(): CategoryOutbound,

37 > },

38 > }

39 > }

40

41 // AddCategory register a Category with the registry or panics if a Category with the same ID has already been

42 // registered.

43 > func (r *MutableTaskCategoryRegistry) AddCategory(c Category) { task_category_registry.go

44 > if category, ok := r.categories[c.id]; ok {

45 panic(fmt.Sprintf(

46 "category id: %v has already been defined as type %v and name %v",

51 }

52

53 > r.categories[c.id] = c task_category_registry.go

54 }

55

61

62 // GetCategories returns a deep copy of all registered Category objects from the registry.

63 > func (r *MutableTaskCategoryRegistry) GetCategories() map[int]Category { task_category_registry.go

64 > return maps.Clone(r.categories)

65 > }

go.temporal.io/server/common/definition/workflow_key.go 16 covered LOC · 4 ranges

Open complete file

19 workflowID string,

20 runID string,

21 > ) WorkflowKey { workflow_key.go

22 > return WorkflowKey{

23 > NamespaceID: namespaceID,

24 > WorkflowID: workflowID,

25 > RunID: runID,

26 > }

27 > }

28

29 > func (k *WorkflowKey) GetNamespaceID() string { workflow_key.go

30 > return k.NamespaceID

31 > }

32

33 > func (k *WorkflowKey) GetWorkflowID() string { workflow_key.go

34 > return k.WorkflowID

35 > }

36

37 > func (k *WorkflowKey) GetRunID() string { workflow_key.go

38 > return k.RunID

39 > }

40

41 func (k *WorkflowKey) String() string {

go.temporal.io/server/common/persistence/transitionhistory/transition_history.go 16 covered LOC · 10 ranges

Open complete file

34 func LastVersionedTransition(

35 transitions []*persistencespb.VersionedTransition,

36 > ) *persistencespb.VersionedTransition { transition_history.go

37 > if len(transitions) == 0 {

38 > // transition history is not enabled transition_history.go

39 > return nil

40 > }

41 > return transitions[len(transitions)-1] transition_history.go

42 }

43

51 func Compare(

52 a, b *persistencespb.VersionedTransition,

53 > ) int { transition_history.go

54 > if a.GetNamespaceFailoverVersion() < b.GetNamespaceFailoverVersion() {

55 > return -1 transition_history.go

56 > }

57 > if a.GetNamespaceFailoverVersion() > b.GetNamespaceFailoverVersion() { transition_history.go

58 > return 1 transition_history.go

59 > }

60

61 > if a.GetTransitionCount() < b.GetTransitionCount() { transition_history.go

62 return -1

63 }

64 > if a.GetTransitionCount() > b.GetTransitionCount() { transition_history.go

65 return 1

66 }

67

68 > return 0 transition_history.go

69 }

70

go.temporal.io/server/service/history/interfaces/engine_mock.go 16 covered LOC · 4 ranges

Open complete file

45

46 // NewMockEngine creates a new mock instance.

47 > func NewMockEngine(ctrl *gomock.Controller) *MockEngine { engine_mock.go

48 > mock := &MockEngine{ctrl: ctrl}

49 > mock.recorder = &MockEngineMockRecorder{mock}

50 > return mock

51 > }

52

53 // EXPECT returns an object that allows the caller to indicate expected use.

54 > func (m *MockEngine) EXPECT() *MockEngineMockRecorder { engine_mock.go

55 > return m.recorder

56 > }

57

58 // AddTasks mocks base method.

434

435 // NotifyNewHistoryEvent indicates an expected call of NotifyNewHistoryEvent.

436 > func (mr *MockEngineMockRecorder) NotifyNewHistoryEvent(event any) *gomock.Call { engine_mock.go

437 > mr.mock.ctrl.T.Helper()

438 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyNewHistoryEvent", reflect.TypeOf((*MockEngine)(nil).NotifyNewHistoryEvent), event)

439 > }

440

441 // NotifyNewTasks mocks base method.

446

447 // NotifyNewTasks indicates an expected call of NotifyNewTasks.

448 > func (mr *MockEngineMockRecorder) NotifyNewTasks(arg0 any) *gomock.Call { engine_mock.go

449 > mr.mock.ctrl.T.Helper()

450 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyNewTasks", reflect.TypeOf((*MockEngine)(nil).NotifyNewTasks), arg0)

451 > }

452

453 // PauseActivity mocks base method.

go.temporal.io/server/service/history/tasks/key.go 16 covered LOC · 5 ranges

Open complete file

28 )

29

30 > func NewImmediateKey(taskID int64) Key { key.go

31 > return Key{

32 > FireTime: DefaultFireTime,

33 > TaskID: taskID,

34 > }

35 > }

36

37 > func NewKey(fireTime time.Time, taskID int64) Key { key.go

38 > return Key{

39 > FireTime: fireTime,

40 > TaskID: taskID,

41 > }

42 > }

43

44 func ValidateKey(key Key) error {

54 }

55

56 > func (left Key) CompareTo(right Key) int { key.go

57 > if left.FireTime.Before(right.FireTime) {

58 > return -1 key.go

59 > } else if left.FireTime.After(right.FireTime) { key.go

60 return 1

61 }

go.temporal.io/server/common/persistence/visibility/store/sql/query_converter_util_legacy.go 15 covered LOC · 3 ranges

Open complete file

68 }

69

70 > func newColName(name string) *colName { query_converter_util_legacy.go

71 > return &colName{Name: name}

72 > }

73

74 func newSAColName(

77 fieldName string,

78 valueType enumspb.IndexedValueType,

79 > ) *saColName { query_converter_util_legacy.go

80 > return &saColName{

81 > dbColName: newColName(dbColName),

82 > alias: alias,

83 > fieldName: fieldName,

84 > valueType: valueType,

85 > }

86 > }

87

88 func newFuncExpr(name string, exprs ...sqlparser.Expr) *sqlparser.FuncExpr {

105 }

106

107 > func getMaxDatetimeValue() time.Time { query_converter_util_legacy.go

108 > t, _ := time.Parse(time.RFC3339, "9999-12-31T23:59:59Z")

109 > return t

110 > }

111

112 // formatComparisonExprStringForError formats comparison expression after

go.temporal.io/server/service/history/shard/handover_tracker.go 15 covered LOC · 3 ranges

Open complete file

63

64 // NewDefaultHandoverTrackerFactory returns a factory that creates the default OSS HandoverTracker.

65 > func NewDefaultHandoverTrackerFactory() HandoverTrackerFactory { handover_tracker.go

66 > return func(params HandoverTrackerParams) HandoverTracker {

67 > return &defaultHandoverTracker{ handover_tracker.go

68 > handoverNamespaces: make(map[namespace.Name]*namespaceHandOverInfo),

69 > clusterMetadata: params.ClusterMetadata,

70 > getMaxReplicationTaskID: params.GetMaxReplicationTaskID,

71 > errorByStateFn: params.ErrorByStateFn,

72 > notifyReplicationFn: params.NotifyReplicationFn,

73 > logger: params.Logger,

74 > }

75 > }

76 }

77

113 }

114

115 > func (t *defaultHandoverTracker) IsInHandover(namespaceName namespace.Name, workflowID string) bool { handover_tracker.go

116 > _, ok := t.handoverNamespaces[namespaceName]

117 > return ok

118 > }

119

120 func (t *defaultHandoverTracker) GetHandoverNamespaces() map[string]*historyservice.HandoverNamespaceInfo {

go.temporal.io/server/service/history/tasks/sync_versioned_transition_task.go 15 covered LOC · 5 ranges

Open complete file

36 )

37

38 > func (a *SyncVersionedTransitionTask) GetKey() Key { sync_versioned_transition_task.go

39 > return NewImmediateKey(a.TaskID)

40 > }

41

42 func (a *SyncVersionedTransitionTask) GetTaskID() int64 {

44 }

45

46 > func (a *SyncVersionedTransitionTask) SetTaskID(id int64) { sync_versioned_transition_task.go

47 > a.TaskID = id

48 > }

49

50 > func (a *SyncVersionedTransitionTask) GetVisibilityTime() time.Time { sync_versioned_transition_task.go

51 > return a.VisibilityTimestamp

52 > }

53

54 > func (a *SyncVersionedTransitionTask) SetVisibilityTime(timestamp time.Time) { sync_versioned_transition_task.go

55 > a.VisibilityTimestamp = timestamp

56 > }

57

58 func (a *SyncVersionedTransitionTask) GetCategory() Category {

60 }

61

62 > func (a *SyncVersionedTransitionTask) GetType() enumsspb.TaskType { sync_versioned_transition_task.go

63 > return enumsspb.TASK_TYPE_REPLICATION_SYNC_VERSIONED_TRANSITION

64 > }

65

66 func (a *SyncVersionedTransitionTask) GetArchetypeID() uint32 {

go.temporal.io/server/common/build/build.go 14 covered LOC · 2 ranges

Open complete file

27 )

28

29 > func init() { build.go

30 > buildInfo, ok := debug.ReadBuildInfo()

31 > if !ok {

32 return

33 }

34

35 > InfoData.Available = true build.go

36 > InfoData.GoVersion = buildInfo.GoVersion

37 >

38 > for _, setting := range buildInfo.Settings {

39 > switch setting.Key {

40 > case "GOARCH":

41 > InfoData.GoArch = setting.Value

42 > case "GOOS":

43 > InfoData.GoOs = setting.Value

44 > case "CGO_ENABLED":

45 > InfoData.CgoEnabled = setting.Value == "1"

46 case "vcs.revision":

47 InfoData.GitRevision = setting.Value

go.temporal.io/server/common/dynamicconfig/gradual_change.go 14 covered LOC · 3 ranges

Open complete file

25 // StaticGradualChange returns a GradualChange whose Value always returns def and whose When

26 // always returns a time in the past.

27 > func StaticGradualChange[T any](def T) GradualChange[T] { gradual_change.go

28 > return GradualChange[T]{New: def}

29 > }

30

31 // Value returns the value for the given key at the given time.

56 // of type GradualChange into a GradualChange.

57 // nolint:revive // cognitive-complexity // this looks complicated but each case is fairly simple

58 > func ConvertGradualChange[T any](def T) func(v any) (GradualChange[T], error) { gradual_change.go

59 > changeConverter := ConvertStructure(StaticGradualChange(def))

60 >

61 > // Call this once so that if it's going to panic, it panics at static init time.

62 > _, _ = changeConverter(nil)

63 >

64 > switch reflect.TypeFor[T]() {

65 > case reflect.TypeFor[bool]():

66 > return func(v any) (GradualChange[T], error) {

67 if b, err := convertBool(v); err == nil {

68 var change GradualChange[T]

72 return changeConverter(v)

73 }

74 > case reflect.TypeFor[int](): gradual_change.go

75 > return func(v any) (GradualChange[T], error) {

76 if i, err := convertInt(v); err == nil {

77 var change GradualChange[T]

go.temporal.io/server/service/history/workflow/workflow_task_state_machine.go 14 covered LOC · 4 ranges

Open complete file

53 ms *MutableStateImpl,

54 metricsHandler metrics.Handler,

55 > ) *workflowTaskStateMachine { workflow_task_state_machine.go

56 > return &workflowTaskStateMachine{

57 > ms: ms,

58 > metricsHandler: metricsHandler,

59 > }

60 > }

61

62 func (m *workflowTaskStateMachine) ApplyWorkflowTaskScheduledEvent(

1196 }

1197

1198 > func (m *workflowTaskStateMachine) HasStartedWorkflowTask() bool { workflow_task_state_machine.go

1199 > return m.ms.executionInfo.WorkflowTaskScheduledEventId != common.EmptyEventID &&

1200 > m.ms.executionInfo.WorkflowTaskStartedEventId != common.EmptyEventID

1201 > }

1202

1203 func (m *workflowTaskStateMachine) GetStartedWorkflowTask() *historyi.WorkflowTaskInfo {

1515 }

1516

1517 > func (m *workflowTaskStateMachine) convertSpeculativeWorkflowTaskToNormal() error { workflow_task_state_machine.go

1518 > if m.ms.executionInfo.WorkflowTaskType != enumsspb.WORKFLOW_TASK_TYPE_SPECULATIVE {

1519 > return nil workflow_task_state_machine.go

1520 > }

1521

1522 // Workflow task can't be persisted as Speculative, because when it is completed,

go.temporal.io/server/chasm/ref.go 13 covered LOC · 4 ranges

Open complete file

61 func NewComponentRef[C Component](

62 executionKey ExecutionKey,

63 > ) ComponentRef { ref.go

64 > return ComponentRef{

65 > ExecutionKey: executionKey,

66 > executionGoType: reflect.TypeFor[C](),

67 > }

68 > }

69

70 // NewComponentRefByArchetypeID creates a new ComponentRef with a known archetype ID.

114 func (r *ComponentRef) ArchetypeID(

115 registry *Registry,

116 > ) (ArchetypeID, error) { ref.go

117 > if r.archetypeID != UnspecifiedArchetypeID {

118 return r.archetypeID, nil

119 }

120

121 > rc, ok := registry.componentOf(r.executionGoType) ref.go

122 > if !ok {

123 return 0, serviceerror.NewInternal("unknown chasm component type: " + r.executionGoType.String())

124 }

125 > r.archetypeID = rc.componentID ref.go

126 >

127 > return r.archetypeID, nil

128 }

129

go.temporal.io/server/common/metrics/defs_base.go 13 covered LOC · 2 ranges

Open complete file

10 }

11

12 > func newMetricDefinition(name string, opts ...Option) metricDefinition { defs_base.go

13 > d := metricDefinition{

14 > name: name,

15 > description: "",

16 > unit: "",

17 > }

18 > for _, opt := range opts {

19 > opt.apply(&d)

20 > }

21 > return d

22 }

23

24 > func (md metricDefinition) Name() string { defs_base.go

25 > return md.name

26 > }

27

28 func (md metricDefinition) Unit() MetricUnit {

go.temporal.io/server/chasm/library.go 12 covered LOC · 4 ranges

Open complete file

34 }

35

36 > func (UnimplementedLibrary) Tasks() []*RegistrableTask { library.go

37 > return nil

38 > }

39

40 // RegisterServices Registers the gRPC calls to the handlers of the library.

42 }

43

44 > func (UnimplementedLibrary) NexusServices() []*nexus.Service { library.go

45 > return nil

46 > }

47

48 > func (UnimplementedLibrary) NexusServiceProcessors() []*NexusServiceProcessor { library.go

49 > return nil

50 > }

51

52 func (UnimplementedLibrary) mustEmbedUnimplementedLibrary() {}

56 // tasks within the CHASM framework.

57 // The format of the returned FQN is: "libName.name"

58 > func FullyQualifiedName(libName, name string) string { library.go

59 > return libName + "." + name

60 > }

go.temporal.io/server/common/metrics/noop_impl.go 12 covered LOC · 6 ranges

Open complete file

15 )

16

17 > func newNoopMetricsHandler() *noopMetricsHandler { return &noopMetricsHandler{} } noop_impl.go

18

19 // WithTags creates a new MetricProvder with provided []Tag

20 // Tags are merged with registered Tags from the source MetricsHandler

21 > func (n *noopMetricsHandler) WithTags(...Tag) Handler { noop_impl.go

22 > return n

23 > }

24

25 // Counter obtains a counter for the given name.

29

30 // Gauge obtains a gauge for the given name.

31 > func (*noopMetricsHandler) Gauge(string) GaugeIface { noop_impl.go

32 > return NoopGaugeMetricFunc

33 > }

34

35 // Timer obtains a timer for the given name.

36 > func (*noopMetricsHandler) Timer(string) TimerIface { noop_impl.go

37 > return NoopTimerMetricFunc

38 > }

39

40 // Histogram obtains a histogram for the given name.

54

55 var NoopCounterMetricFunc = CounterFunc(func(i int64, t ...Tag) {})

56 > var NoopGaugeMetricFunc = GaugeFunc(func(f float64, t ...Tag) {}) noop_impl.go

57 > var NoopTimerMetricFunc = TimerFunc(func(d time.Duration, t ...Tag) {}) noop_impl.go

58 var NoopHistogramMetricFunc = HistogramFunc(func(i int64, t ...Tag) {})

go.temporal.io/server/common/persistence/versionhistory/version_histories.go 12 covered LOC · 5 ranges

Open complete file

7

8 // NewVersionHistories create a new instance of VersionHistories.

9 > func NewVersionHistories(versionHistory *historyspb.VersionHistory) *historyspb.VersionHistories { version_histories.go

10 > if versionHistory == nil {

11 panic("version history cannot be null")

12 }

13

14 > return &historyspb.VersionHistories{ version_histories.go

15 > CurrentVersionHistoryIndex: 0,

16 > Histories: []*historyspb.VersionHistory{versionHistory},

17 > }

18 }

19

32

33 // GetVersionHistory gets the VersionHistory according to index provided.

34 > func GetVersionHistory(h *historyspb.VersionHistories, index int32) (*historyspb.VersionHistory, error) { version_histories.go

35 > if index < 0 || index >= int32(len(h.Histories)) {

36 return nil, serviceerror.NewInternal("version histories index is out of range.")

37 }

38

39 > return h.Histories[index], nil version_histories.go

40 }

41

179

180 // GetCurrentVersionHistory gets the current VersionHistory.

181 > func GetCurrentVersionHistory(h *historyspb.VersionHistories) (*historyspb.VersionHistory, error) { version_histories.go

182 > return GetVersionHistory(h, h.GetCurrentVersionHistoryIndex())

183 > }

184

185 // IsCurrentVersionHistoryEmpty checks if the current VersionHistory is empty.

go.temporal.io/server/common/persistence/visibility/store/elasticsearch/visibility_store.go 12 covered LOC · 3 ranges

Open complete file

101 }

102

103 > defaultSorter = func() []elastic.Sorter { visibility_store.go

104 > ret := make([]elastic.Sorter, 0, len(defaultSorterFields))

105 > for _, item := range defaultSorterFields {

106 > fs := elastic.NewFieldSort(item.name)

107 > if item.desc {

108 > fs.Desc()

109 > }

110 > if item.missing_first {

111 > fs.Missing("_first")

112 > } else {

113 fs.Missing("_last")

114 }

115 > ret = append(ret, fs) visibility_store.go

116 }

117 > return ret visibility_store.go

118 }()

119

go.temporal.io/server/common/primitives/timestamp/duration.go 12 covered LOC · 4 ranges

Open complete file

26 }

27

28 > func DurationPtr(td time.Duration) *durationpb.Duration { duration.go

29 > return durationpb.New(td)

30 > }

31

32 func MinDurationPtr(d1 *durationpb.Duration, d2 *durationpb.Duration) *durationpb.Duration {

35 }

36

37 > func DurationFromSeconds(s int64) *durationpb.Duration { duration.go

38 > return durationMultipleOf(s, time.Second)

39 > }

40

41 func DurationFromMinutes(m int64) *durationpb.Duration {

47 }

48

49 > func DurationFromDays(d int32) *durationpb.Duration { duration.go

50 > return durationMultipleOf(int64(d), time.Hour*24)

51 > }

52

53 > func durationMultipleOf(amt int64, mult time.Duration) *durationpb.Duration { duration.go

54 > return DurationPtr(time.Duration(amt) * mult)

55 > }

56

57 // ValidateAndCapProtoDuration validates protobuf durations for two conditions:

go.temporal.io/server/common/headers/headers.go 11 covered LOC · 4 ranges

Open complete file

45 // GetValues returns header values for passed header names.

46 // It always returns slice of the same size as number of passed header names.

47 > func GetValues(ctx context.Context, headerNames ...string) []string { headers.go

48 > headerValues := make([]string, len(headerNames))

49 >

50 > for i, headerName := range headerNames {

51 > if values := metadata.ValueFromIncomingContext(ctx, headerName); len(values) > 0 {

52 headerValues[i] = values[0]

53 }

54 }

55

56 > return headerValues headers.go

57 }

58

144

145 // GetPrincipal retrieves the principal from the context headers. Returns nil if principal is not set.

146 > func GetPrincipal(ctx context.Context) *commonpb.Principal { headers.go

147 > values := GetValues(ctx, PrincipalTypeHeaderName, PrincipalNameHeaderName)

148 > if values[0] == "" && values[1] == "" {

149 > return nil headers.go

150 > }

151 return &commonpb.Principal{Type: values[0], Name: values[1]}

152 }

go.temporal.io/server/common/metrics/grpc.go 11 covered LOC · 4 ranges

Open complete file

123

124 // getMetricsContext extracts metrics context from golang context.

125 > func getMetricsContext(ctx context.Context) *metricsContext { grpc.go

126 > metricsCtx := ctx.Value(metricsCtxKey)

127 > if metricsCtx == nil {

128 > return nil grpc.go

129 > }

130

131 return metricsCtx.(*metricsContext)

138

139 // ContextCounterAdd adds value to counter within metrics context.

140 > func ContextCounterAdd(ctx context.Context, name string, value int64) bool { grpc.go

141 > metricsCtx := getMetricsContext(ctx)

142 >

143 > if metricsCtx == nil {

144 > return false grpc.go

145 > }

146

147 metricsCtx.Lock()

go.temporal.io/server/common/util/util.go 11 covered LOC · 4 ranges

Open complete file

20

21 // MaxTime returns the latest of the given time.Time values.

22 > func MaxTime(first time.Time, rest ...time.Time) time.Time { util.go

23 > latest := first

24 > for _, t := range rest {

25 > if t.After(latest) {

26 > latest = t util.go

27 > }

28 }

29 > return latest util.go

30 }

31

68

69 // InverseMap creates the inverse map, ie., for a key-value map, it builds the value-key map.

70 > func InverseMap[M ~map[K]V, K, V comparable](m M) map[V]K { util.go

71 > if m == nil {

72 > return nil

73 > }

74 invm := make(map[V]K, len(m))

75 for k, v := range m {

go.temporal.io/server/service/history/tests/vars.go 11 covered LOC · 1 range

Open complete file

158 )

159

160 > func NewDynamicConfig() *configs.Config { vars.go

161 > dc := dynamicconfig.NewNoopCollection()

162 > config := configs.NewConfig(dc, 1)

163 > config.EnableActivityEagerExecution = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)

164 > config.NamespaceCacheRefreshInterval = dynamicconfig.GetDurationPropertyFn(time.Second)

165 > config.ReplicationEnableUpdateWithNewTaskMerge = dynamicconfig.GetBoolPropertyFn(true)

166 > config.EnableWorkflowIdReuseStartTimeValidation = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)

167 > config.EnableTransitionHistory = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)

168 > config.EnableChasm = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(false)

169 > return config

170 > }

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/plugin.go 10 covered LOC · 1 range

Open complete file

36 var _ sqlplugin.Plugin = (*plugin)(nil)

37

38 > func init() { plugin.go

39 > sql.RegisterPlugin(PluginName, &plugin{

40 > driver: &driver.PQDriver{},

41 > queryConverter: &queryConverter{},

42 > })

43 > sql.RegisterPlugin(PluginNamePGX, &plugin{

44 > driver: &driver.PGXDriver{},

45 > queryConverter: &queryConverter{},

46 > })

47 > }

48

49 func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/visibility.go 10 covered LOC · 1 range

Open complete file

40 )

41

42 > func buildOnDuplicateKeyUpdate(fields ...string) string { visibility.go

43 > items := make([]string, len(fields))

44 > for i, field := range fields {

45 > items[i] = fmt.Sprintf("%s = excluded.%s", field, field)

46 > }

47 > return fmt.Sprintf(

48 > // The WHERE clause ensures that no update occurs if the version is behind the saved version.

49 > "ON CONFLICT (namespace_id, run_id) DO UPDATE SET %s WHERE executions_visibility.%s < EXCLUDED.%s",

50 > strings.Join(items, ", "), sqlplugin.VersionColumnName, sqlplugin.VersionColumnName,

51 > )

52 }

53

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/visibility.go 10 covered LOC · 1 range

Open complete file

42 )

43

44 > func buildOnDuplicateKeyUpdate(fields ...string) string { visibility.go

45 > items := make([]string, len(fields))

46 > for i, field := range fields {

47 > items[i] = fmt.Sprintf("%s = excluded.%s", field, field)

48 > }

49 > return fmt.Sprintf(

50 > // The WHERE clause ensures that no update occurs if the version is behind the saved version.

51 > "ON CONFLICT (namespace_id, run_id) DO UPDATE SET %s WHERE executions_visibility.%s < EXCLUDED.%s",

52 > strings.Join(items, ", "), sqlplugin.VersionColumnName, sqlplugin.VersionColumnName,

53 > )

54 }

55

go.temporal.io/server/common/persistence/sql/sqlplugin/visibility.go 10 covered LOC · 2 ranges

Open complete file

219 }

220

221 > func getDbFields() []string { visibility.go

222 > t := reflect.TypeFor[VisibilityRow]()

223 > dbFields := make([]string, t.NumField())

224 > for i := 0; i < t.NumField(); i++ {

225 > f := t.Field(i)

226 > dbFields[i] = f.Tag.Get("db")

227 > if dbFields[i] == "" {

228 > dbFields[i] = strcase.ToSnake(f.Name)

229 > }

230 }

231 > return dbFields visibility.go

232 }

233

go.temporal.io/server/common/persistence/visibility/store/query/util.go 10 covered LOC · 2 ranges

Open complete file

70 }

71

72 > func NewUnsafeSQLString(val string) *UnsafeSQLString { util.go

73 > return &UnsafeSQLString{Val: val}

74 > }

75

76 func NewColName(name string) *ColumnName {

78 }

79

80 > func NewSAColumn(alias string, fieldName string, valueType enumspb.IndexedValueType) *SAColumn { util.go

81 > return &SAColumn{

82 > Alias: alias,

83 > FieldName: fieldName,

84 > ValueType: valueType,

85 > }

86 > }

87

88 func NamespaceDivisionSAColumn() *SAColumn {

go.temporal.io/server/common/searchattribute/search_attribute_mock.go 10 covered LOC · 2 ranges

Open complete file

31

32 // NewMockProvider creates a new mock instance.

33 > func NewMockProvider(ctrl *gomock.Controller) *MockProvider { search_attribute_mock.go

34 > mock := &MockProvider{ctrl: ctrl}

35 > mock.recorder = &MockProviderMockRecorder{mock}

36 > return mock

37 > }

38

39 // EXPECT returns an object that allows the caller to indicate expected use.

70

71 // NewMockManager creates a new mock instance.

72 > func NewMockManager(ctrl *gomock.Controller) *MockManager { search_attribute_mock.go

73 > mock := &MockManager{ctrl: ctrl}

74 > mock.recorder = &MockManagerMockRecorder{mock}

75 > return mock

76 > }

77

78 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/chasm/visibility.go 9 covered LOC · 1 range

Open complete file

64

65 // newVisibilitySearchAttributesMapper returns a mapper with all maps initialized.

66 > func newVisibilitySearchAttributesMapper() *VisibilitySearchAttributesMapper { visibility.go

67 > return &VisibilitySearchAttributesMapper{

68 > aliasToField: make(map[string]string),

69 > fieldToAlias: make(map[string]string),

70 > saTypeMap: make(map[string]enumspb.IndexedValueType),

71 > systemAliasToField: make(map[string]string),

72 > overriddenSystemFields: make(map[string]enumspb.IndexedValueType),

73 > }

74 > }

75

76 // Alias returns the alias for a given field.

go.temporal.io/server/common/archiver/archival_metadata.go 9 covered LOC · 1 range

Open complete file

127

128 // NewDisabledArchvialConfig returns an ArchivalConfig where archival is disabled for both the cluster and the namespace

129 > func NewDisabledArchvialConfig() ArchivalConfig { archival_metadata.go

130 > return &archivalConfig{

131 > staticClusterState: ArchivalDisabled,

132 > dynamicClusterState: nil,

133 > enableRead: nil,

134 > namespaceDefaultState: enumspb.ARCHIVAL_STATE_DISABLED,

135 > namespaceDefaultURI: "",

136 > }

137 > }

138

139 // NewEnabledArchivalConfig returns an ArchivalConfig where archival is enabled for both the cluster and the namespace

go.temporal.io/server/common/dynamicconfig/static_client.go 9 covered LOC · 4 ranges

Open complete file

10 )

11

12 > func (s StaticClient) GetValue(key Key) []ConstrainedValue { static_client.go

13 > if v, ok := s[key]; ok {

14 if cvs, ok := v.([]ConstrainedValue); ok {

15 return cvs

17 return []ConstrainedValue{{Value: v}}

18 }

19 > return nil static_client.go

20 }

21

22 // NewNoopClient returns a Client that has no keys (a Collection using it will always return

23 // default values).

24 > func NewNoopClient() Client { static_client.go

25 > return StaticClient(nil)

26 > }

27

28 // NewNoopCollection creates a new noop collection.

29 > func NewNoopCollection() *Collection { static_client.go

30 > return NewCollection(NewNoopClient(), log.NewNoopLogger())

31 > }

go.temporal.io/server/common/persistence/sql/sqlplugin/util.go 9 covered LOC · 2 ranges

Open complete file

5 )

6

7 > func appendPrefix(prefix string, fields []string) []string { util.go

8 > out := make([]string, len(fields))

9 > for i, field := range fields {

10 > out[i] = prefix + field

11 > }

12 > return out

13 }

14

15 > func BuildNamedPlaceholder(fields ...string) string { util.go

16 > return strings.Join(appendPrefix(":", fields), ", ")

17 > }

go.temporal.io/server/common/testing/testhooks/test_impl.go 9 covered LOC · 2 ranges

Open complete file

89 var keyCounter atomic.Int64

90

91 > func newKey[T any, S any]() Key[T, S] { test_impl.go

92 > var zero S

93 > var s ScopeType

94 > switch any(zero).(type) {

95 > case namespace.ID, namespace.Name:

96 > s = ScopeNamespace

97 > case global:

98 > s = ScopeGlobal

99 default:

100 panic("testhooks: unknown scope type")

101 }

102 > return Key[T, S]{id: keyCounter.Add(1), scopeType: s} test_impl.go

103 }

go.temporal.io/server/common/testing/testvars/any.go 9 covered LOC · 2 ranges

Open complete file

18 }

19

20 > func newAny(testName string, testHash uint32) Any { any.go

21 > return Any{

22 > testName: testName,

23 > testHash: testHash,

24 > }

25 > }

26

27 func (a Any) String() string {

77 }

78

79 > func (a Any) RunID() string { any.go

80 > return uuid.NewString()

81 > }

82

83 func (a Any) WorkflowKey() definition.WorkflowKey {

go.temporal.io/server/service/history/tasks/category.go 9 covered LOC · 3 ranges

Open complete file

96 }

97

98 > func (c Category) ID() int { category.go

99 > return c.id

100 > }

101

102 > func (c Category) Name() string { category.go

103 > return c.name

104 > }

105

106 > func (c Category) Type() CategoryType { category.go

107 > return c.cType

108 > }

109

110 func (c Category) MarshalText() (text []byte, err error) {

go.temporal.io/server/service/history/workflow/mutable_state_state_status.go 9 covered LOC · 4 ranges

Open complete file

18 state enumsspb.WorkflowExecutionState,

19 status enumspb.WorkflowExecutionStatus,

20 > ) error { mutable_state_state_status.go

21 > switch e.GetState() {

22 case enumsspb.WORKFLOW_EXECUTION_STATE_VOID:

23 // no validation

24 > case enumsspb.WORKFLOW_EXECUTION_STATE_CREATED: mutable_state_state_status.go

25 > switch state {

26 case enumsspb.WORKFLOW_EXECUTION_STATE_CREATED:

27 if status != enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING {

29 }

30

31 > case enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING: mutable_state_state_status.go

32 > if status != enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING && status != enumspb.WORKFLOW_EXECUTION_STATUS_PAUSED {

33 return invalidStateTransitionErr(e.GetState(), state, status)

34 }

120 }

121

122 > e.State = state mutable_state_state_status.go

123 > e.Status = status

124 > return nil

125 }

126

go.temporal.io/server/service/history/workflow/state_machine_definition.go 9 covered LOC · 3 ranges

Open complete file

25

26 // Serialize is a noop as Deserialize is not supported.

27 > func (stateMachineDefinition) Serialize(any) ([]byte, error) { state_machine_definition.go

28 > return nil, nil

29 > }

30

31 > func (stateMachineDefinition) Type() string { state_machine_definition.go

32 > return StateMachineType

33 > }

34

35 > func RegisterStateMachine(reg *hsm.Registry) error { state_machine_definition.go

36 > return reg.RegisterMachine(stateMachineDefinition{})

37 > }

go.temporal.io/server/service/history/workflow/state_machine_timers.go 9 covered LOC · 3 ranges

Open complete file

16 // AddNextStateMachineTimerTask generates a state machine timer task if the first deadline doesn't have a task scheduled

17 // yet.

18 > func AddNextStateMachineTimerTask(ms historyi.MutableState) { state_machine_timers.go

19 > // filter out empty timer groups

20 > timers := ms.GetExecutionInfo().StateMachineTimers

21 > timers = slices.DeleteFunc(timers, func(timerGroup *persistencespb.StateMachineTimerGroup) bool {

22 return len(timerGroup.Infos) == 0

23 })

24 > ms.GetExecutionInfo().StateMachineTimers = timers state_machine_timers.go

25 >

26 > if len(timers) == 0 {

27 > return state_machine_timers.go

28 > }

29

30 timerGroup := timers[0]

go.temporal.io/server/service/history/workflow/state_transition_history.go 9 covered LOC · 2 ranges

Open complete file

25 history []*persistencespb.VersionedTransition,

26 namespaceFailoverVersion int64,

27 > ) []*persistencespb.VersionedTransition { state_transition_history.go

28 > if len(history) == 0 {

29 > return []*persistencespb.VersionedTransition{ state_transition_history.go

30 > {

31 > NamespaceFailoverVersion: namespaceFailoverVersion,

32 > TransitionCount: 1,

33 > },

34 > }

35 > }

36

37 lastTransitionCount := history[len(history)-1].TransitionCount

go.temporal.io/server/service/history/workflow/transaction_impl.go 9 covered LOC · 3 ranges

Open complete file

362 request *persistence.CreateWorkflowExecutionRequest,

363 isWorkflow bool,

364 > ) (*persistence.CreateWorkflowExecutionResponse, error) { transaction_impl.go

365 >

366 > resp, err := shardContext.CreateWorkflowExecution(ctx, request)

367 > if err != nil {

368 > switch err.(type) { transaction_impl.go

369 case *persistence.CurrentWorkflowConditionFailedError,

370 *persistence.WorkflowConditionFailedError,

371 *persistence.ConditionFailedError,

372 > *serviceerror.ResourceExhausted: transaction_impl.go

373 > // it is possible that workflow already exists and caller need to apply

374 > // workflow ID reuse policy, or the error is resource exhausted.

375 > return nil, err

376 default:

377 shardContext.GetLogger().Error(

go.temporal.io/server/chasm/component.go 8 covered LOC · 3 ranges

Open complete file

122 ctx context.Context,

123 intent OperationIntent,

124 > ) context.Context { component.go

125 > return context.WithValue(ctx, operationIntentCtxKey, intent)

126 > }

127

128 func operationIntentFromContext(

129 ctx context.Context,

130 > ) OperationIntent { component.go

131 > intent, ok := ctx.Value(operationIntentCtxKey).(OperationIntent)

132 > if !ok {

133 > return OperationIntentUnspecified component.go

134 > }

135 return intent

136 }

go.temporal.io/server/common/archiver/metadata_mock.go 8 covered LOC · 1 range

Open complete file

20 // NewMetadataMock returns a new MetadataMock which uses the provided controller to create a MockArchivalMetadata

21 // instance.

22 > func NewMetadataMock(controller *gomock.Controller) MetadataMock { metadata_mock.go

23 > m := &metadataMock{

24 > MockArchivalMetadata: NewMockArchivalMetadata(controller),

25 > defaultHistoryConfig: NewDisabledArchvialConfig(),

26 > defaultVisibilityConfig: NewDisabledArchvialConfig(),

27 > }

28 > return m

29 > }

30

31 // MetadataMockRecorder is a wrapper around a ArchivalMetadata mock recorder.

go.temporal.io/server/common/headers/caller_info.go 8 covered LOC · 1 range

Open complete file

156 func GetCallerInfo(

157 ctx context.Context,

158 > ) CallerInfo { caller_info.go

159 > values := GetValues(ctx, CallerNameHeaderName, CallerTypeHeaderName, CallOriginHeaderName)

160 > return CallerInfo{

161 > CallerName: values[0],

162 > CallerType: values[1],

163 > CallOrigin: values[2],

164 > }

165 > }

go.temporal.io/server/common/namespace/mutate.go 8 covered LOC · 2 ranges

Open complete file

8 type mutationFunc func(*Namespace)

9

10 > func (f mutationFunc) apply(ns *Namespace) { mutate.go

11 > f(ns)

12 > }

13

14 // WithActiveCluster assigns the active cluster to a Namespace during a Clone

43

44 // WithGlobalFlag sets whether or not this Namespace is global.

45 > func WithGlobalFlag(b bool) Mutation { mutate.go

46 > return mutationFunc(

47 > func(ns *Namespace) {

48 > ns.replicationResolver.SetGlobalFlag(b)

49 > })

50 }

51

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/visibility.go 8 covered LOC · 1 range

Open complete file

73 )

74

75 > func buildOnDuplicateKeyUpdate(fields ...string) string { visibility.go

76 > items := make([]string, len(fields))

77 > for i, field := range fields {

78 > // This line is to ensure that no update occurs (for any column) if the version is behind the saved version.

79 > items[i] = fmt.Sprintf("%v = IF(%v < VALUES(%v), VALUES(%v), %v)",

80 > field, sqlplugin.VersionColumnName, sqlplugin.VersionColumnName, field, field)

81 > }

82 > return fmt.Sprintf("ON DUPLICATE KEY UPDATE %s", strings.Join(items, ", "))

83 }

84

go.temporal.io/server/common/tasks/priority.go 8 covered LOC · 2 ranges

Open complete file

59 )

60

61 > func (p Priority) String() string { priority.go

62 > s, ok := PriorityName[p]

63 > if ok {

64 > return s

65 > }

66 return strconv.Itoa(int(p))

67 }

77 func getPriority(

78 class, subClass Priority,

79 > ) Priority { priority.go

80 > return class | subClass

81 > }

go.temporal.io/server/service/history/workflow/query_registry.go 8 covered LOC · 1 range

Open complete file

25 )

26

27 > func NewQueryRegistry() historyi.QueryRegistry { query_registry.go

28 > return &queryRegistryImpl{

29 > buffered: make(map[string]query),

30 > completed: make(map[string]query),

31 > unblocked: make(map[string]query),

32 > failed: make(map[string]query),

33 > }

34 > }

35

36 func (r *queryRegistryImpl) HasBufferedQuery() bool {

go.temporal.io/server/chasm/statemachine.go 7 covered LOC · 1 range

Open complete file

34 // The apply function is called after verifying the transition is possible but before setting the destination state,

35 // so it can inspect the current (source) state.

36 > func NewTransition[S comparable, SM StateMachine[S], E any](src []S, dst S, apply func(SM, MutableContext, E) error) Transition[S, SM, E] { statemachine.go

37 > return Transition[S, SM, E]{

38 > Sources: src,

39 > Destination: dst,

40 > apply: apply,

41 > }

42 > }

43

44 // Possible returns a boolean indicating whether the transition is possible for the current state.

go.temporal.io/server/common/dynamicconfig/registry.go 7 covered LOC · 3 ranges

Open complete file

17 )

18

19 > func register(s GenericSetting) { registry.go

20 > if globalRegistry.queried.Load() {

21 panic("dynamicconfig.New*Setting must only be called from static initializers")

22 }

23 > if globalRegistry.settings == nil { registry.go

24 > globalRegistry.settings = make(map[Key]GenericSetting)

25 > }

26 > if globalRegistry.settings[s.Key()] != nil {

27 // nolint:forbidigo // only called during static initialization

28 panic(fmt.Sprintf("duplicate registration of dynamic config key: %q", s.Key().String()))

29 }

30 > globalRegistry.settings[s.Key()] = s registry.go

31 }

32

go.temporal.io/server/common/membership/grpc_resolver.go 7 covered LOC · 2 ranges

Open complete file

53 )

54

55 > func init() { grpc_resolver.go

56 > // This must be called in init to avoid race conditions.

57 > resolver.Register(&globalGrpcBuilder)

58 > }

59

60 // Most code should not use this, this is only exposed for code that has to recognize and use a

80 }

81

82 > func (m *grpcBuilder) Scheme() string { grpc_resolver.go

83 > return grpcResolverScheme

84 > }

85

86 func (m *grpcBuilder) getServiceResolver(u *url.URL) (ServiceResolver, error) {

go.temporal.io/server/service/history/hsm/sm.go 7 covered LOC · 1 range

Open complete file

41 // NewTransition creates a new [Transition] from the given source states to a destination state for a given event.

42 // The apply function is called after verifying the transition is possible and setting the destination state.

43 > func NewTransition[S comparable, SM StateMachine[S], E any](src []S, dst S, apply func(SM, E) (TransitionOutput, error)) Transition[S, SM, E] { sm.go

44 > return Transition[S, SM, E]{

45 > Sources: src,

46 > Destination: dst,

47 > apply: apply,

48 > }

49 > }

50

51 // Possible returns a boolean indicating whether the transition is possible for the current state.

go.temporal.io/server/service/history/vclock/vclock.go 7 covered LOC · 1 range

Open complete file

10 shardID int32,

11 clock int64,

12 > ) *clockspb.VectorClock { vclock.go

13 > return &clockspb.VectorClock{

14 > ClusterId: clusterID,

15 > ShardId: shardID,

16 > Clock: clock,

17 > }

18 > }

19

20 func Comparable(

go.temporal.io/server/api/persistence/v1/executions.go-helpers.pb.go 6 covered LOC · 2 ranges

Open complete file

54

55 // Size returns the size of the object, in bytes, once serialized

56 > func (val *WorkflowExecutionInfo) Size() int { executions.go-helpers.pb.go

57 > return proto.Size(val)

58 > }

59

60 // Equal returns whether two WorkflowExecutionInfo values are equivalent by recursively

239

240 // Size returns the size of the object, in bytes, once serialized

241 > func (val *WorkflowExecutionState) Size() int { executions.go-helpers.pb.go

242 > return proto.Size(val)

243 > }

244

245 // Equal returns whether two WorkflowExecutionState values are equivalent by recursively

go.temporal.io/server/common/clock/time_source.go 6 covered LOC · 2 ranges

Open complete file

31

32 // NewRealTimeSource returns a timeSource that uses the real wall timeSource time.

33 > func NewRealTimeSource() RealTimeSource { time_source.go

34 > return RealTimeSource{}

35 > }

36

37 // Now returns the current time, with the location set to UTC.

38 > func (ts RealTimeSource) Now() time.Time { time_source.go

39 > return time.Now().UTC()

40 > }

41

42 // Since returns the time elapsed since t

go.temporal.io/server/common/log/lazy_logger.go 6 covered LOC · 1 range

Open complete file

19 )

20

21 > func NewLazyLogger(logger Logger, tagFn func() []tag.Tag) *lazyLogger { lazy_logger.go

22 > return &lazyLogger{

23 > logger: logger,

24 > tagFn: tagFn,

25 > }

26 > }

27

28 func (l *lazyLogger) Debug(msg string, tags ...tag.Tag) {

go.temporal.io/server/common/metrics/option.go 6 covered LOC · 2 ranges

Open complete file

10 type WithDescription string

11

12 > func (h WithDescription) apply(m *metricDefinition) { option.go

13 > m.description = string(h)

14 > }

15

16 // WithUnit sets the unit of a metric. See NewBytesHistogramDef for an example.

17 type WithUnit MetricUnit

18

19 > func (h WithUnit) apply(m *metricDefinition) { option.go

20 > m.unit = MetricUnit(h)

21 > }

go.temporal.io/server/common/persistence/data_interfaces.go 6 covered LOC · 3 ranges

Open complete file

1408 // UnixMilliseconds returns t as a Unix time, the number of milliseconds elapsed since January 1, 1970 UTC.

1409 // It should be used for all CQL timestamp.

1410 > func UnixMilliseconds(t time.Time) int64 { data_interfaces.go

1411 > // Handling zero time separately because UnixNano is undefined for zero times.

1412 > if t.IsZero() {

1413 return 0

1414 }

1415

1416 > unixNano := t.UnixNano() data_interfaces.go

1417 > if unixNano < 0 {

1418 // Time is before January 1, 1970 UTC

1419 return 0

1420 }

1421 > return unixNano / int64(time.Millisecond) data_interfaces.go

1422 }

1423

go.temporal.io/server/common/persistence/nosql/nosqlplugin/cassandra/translator/fixed_address_translator.go 6 covered LOC · 2 ranges

Open complete file

15 )

16

17 > func init() { fixed_address_translator.go

18 > RegisterTranslator(fixedTranslatorName, NewFixedAddressTranslatorPlugin())

19 > }

20

21 type FixedAddressTranslatorPlugin struct {

22 }

23

24 > func NewFixedAddressTranslatorPlugin() TranslatorPlugin { fixed_address_translator.go

25 > return &FixedAddressTranslatorPlugin{}

26 > }

27

28 // GetTranslator What gocql driver does is that it will connect to the first node in the list in configuration

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/plugin.go 6 covered LOC · 1 range

Open complete file

43 }

44

45 > func init() { plugin.go

46 > sql.RegisterPlugin(PluginName, &plugin{

47 > queryConverter: &queryConverter{},

48 > connPool: newConnPool(),

49 > })

50 > }

51

52 func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/common/rpc/context.go 6 covered LOC · 1 range

Open complete file

25

26 // CopyContextValues copies values in source Context to destination Context.

27 > func CopyContextValues(dst context.Context, src context.Context) context.Context { context.go

28 > return &valueCopyCtx{

29 > Context: dst,

30 > valueCtx: src,

31 > }

32 > }

33

34 // ResetContextTimeout creates new context with specified timeout and copies values from source Context.

go.temporal.io/server/service/history/configs/task.go 6 covered LOC · 1 range

Open complete file

26 func ConvertWeightsToDynamicConfigValue(

27 weights map[tasks.Priority]int,

28 > ) map[string]any { task.go

29 > weightsForDC := make(map[string]any)

30 > for priority, weight := range weights {

31 > weightsForDC[priority.String()] = weight

32 > }

33 > return weightsForDC

34 }

35

go.temporal.io/server/api/adminservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

33

34 // NewMockAdminServiceClient creates a new mock instance.

35 > func NewMockAdminServiceClient(ctrl *gomock.Controller) *MockAdminServiceClient { service_grpc.pb.mock.go

36 > mock := &MockAdminServiceClient{ctrl: ctrl}

37 > mock.recorder = &MockAdminServiceClientMockRecorder{mock}

38 > return mock

39 > }

40

41 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/api/historyservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

33

34 // NewMockHistoryServiceClient creates a new mock instance.

35 > func NewMockHistoryServiceClient(ctrl *gomock.Controller) *MockHistoryServiceClient { service_grpc.pb.mock.go

36 > mock := &MockHistoryServiceClient{ctrl: ctrl}

37 > mock.recorder = &MockHistoryServiceClientMockRecorder{mock}

38 > return mock

39 > }

40

41 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/api/matchingservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

32

33 // NewMockMatchingServiceClient creates a new mock instance.

34 > func NewMockMatchingServiceClient(ctrl *gomock.Controller) *MockMatchingServiceClient { service_grpc.pb.mock.go

35 > mock := &MockMatchingServiceClient{ctrl: ctrl}

36 > mock.recorder = &MockMatchingServiceClientMockRecorder{mock}

37 > return mock

38 > }

39

40 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/chasm/engine.go 5 covered LOC · 1 range

Open complete file

184 reusePolicy BusinessIDReusePolicy,

185 conflictPolicy BusinessIDConflictPolicy,

186 > ) TransitionOption { engine.go

187 > return func(opts *TransitionOptions) {

188 > opts.ReusePolicy = reusePolicy

189 > opts.ConflictPolicy = conflictPolicy

190 > }

191 }

192

go.temporal.io/server/chasm/lib/nexusoperation/config.go 5 covered LOC · 1 range

Open complete file

160 }

161

162 > func (cfg RetryPolicyConfig) build() backoff.RetryPolicy { config.go

163 > return backoff.NewExponentialRetryPolicy(cfg.InitialInterval).

164 > WithMaximumInterval(cfg.MaxInterval).

165 > WithExpirationInterval(backoff.NoInterval)

166 > }

167

168 var defaultRetryPolicyConfig = RetryPolicyConfig{

go.temporal.io/server/chasm/lib/scheduler/util.go 5 covered LOC · 1 range

Open complete file

26

27 // serializeConflictToken serializes a conflict token as a byte slice.

28 > func serializeConflictToken(conflictToken int64) []byte { util.go

29 > token := make([]byte, 8)

30 > binary.LittleEndian.PutUint64(token, uint64(conflictToken))

31 > return token

32 > }

33

34 // newTaggedLogger returns a logger tagged with the Scheduler's attributes.

go.temporal.io/server/chasm/nexus_operation_processor.go 5 covered LOC · 1 range

Open complete file

165

166 // NewNexusEndpointProcessor creates a new NexusEndpointProcessor.

167 > func NewNexusEndpointProcessor() *NexusEndpointProcessor { nexus_operation_processor.go

168 > return &NexusEndpointProcessor{

169 > serviceProcessors: make(map[string]*NexusServiceProcessor),

170 > }

171 > }

172

173 // RegisterServiceProcessor adds a service-level processor to the endpoint keyed by its name.

go.temporal.io/server/chasm/path_encoder.go 5 covered LOC · 2 ranges

Open complete file

48 node *Node,

49 path []string,

50 > ) (string, error) { path_encoder.go

51 > if path == nil {

52 path = node.path()

53 }

54

55 > if len(path) == 0 { path_encoder.go

56 > return "", nil

57 > }

58

59 var b strings.Builder

go.temporal.io/server/client/client_factory_mock.go 5 covered LOC · 1 range

Open complete file

41

42 // NewMockFactory creates a new mock instance.

43 > func NewMockFactory(ctrl *gomock.Controller) *MockFactory { client_factory_mock.go

44 > mock := &MockFactory{ctrl: ctrl}

45 > mock.recorder = &MockFactoryMockRecorder{mock}

46 > return mock

47 > }

48

49 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/archiver/archival_metadata_mock.go 5 covered LOC · 1 range

Open complete file

30

31 // NewMockArchivalMetadata creates a new mock instance.

32 > func NewMockArchivalMetadata(ctrl *gomock.Controller) *MockArchivalMetadata { archival_metadata_mock.go

33 > mock := &MockArchivalMetadata{ctrl: ctrl}

34 > mock.recorder = &MockArchivalMetadataMockRecorder{mock}

35 > return mock

36 > }

37

38 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/archiver/provider/provider_mock.go 5 covered LOC · 1 range

Open complete file

30

31 // NewMockArchiverProvider creates a new mock instance.

32 > func NewMockArchiverProvider(ctrl *gomock.Controller) *MockArchiverProvider { provider_mock.go

33 > mock := &MockArchiverProvider{ctrl: ctrl}

34 > mock.recorder = &MockArchiverProviderMockRecorder{mock}

35 > return mock

36 > }

37

38 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/metrics/registry.go 5 covered LOC · 1 range

Open complete file

43

44 // register adds a metric definition to the list of pending metric definitions. This method is thread-safe.

45 > func (c *registry) register(d metricDefinition) { registry.go

46 > c.Lock()

47 > defer c.Unlock()

48 > c.definitions = append(c.definitions, d)

49 > }

50

51 // buildCatalog builds a catalog from the list of pending metric definitions. It is safe to call this method multiple

go.temporal.io/server/common/persistence/error_type.go 5 covered LOC · 2 ranges

Open complete file

3 import "go.temporal.io/api/serviceerror"

4

5 > func OperationPossiblySucceeded(err error) bool { error_type.go

6 > switch err.(type) {

7 case *CurrentWorkflowConditionFailedError,

8 *WorkflowConditionFailedError,

14 *serviceerror.ResourceExhausted,

15 *serviceerror.NotFound,

16 > *serviceerror.NamespaceNotFound: error_type.go

17 > // Persistence failure that means that write was definitely not committed.

18 > return false

19 default:

20 return true

go.temporal.io/server/common/persistence/history_branch_util.go 5 covered LOC · 1 range

Open complete file

41 )

42

43 > func NewHistoryBranchUtil(serializer serialization.Serializer) *HistoryBranchUtilImpl { history_branch_util.go

44 > return &HistoryBranchUtilImpl{

45 > serializer: serializer,

46 > }

47 > }

48

49 func (u *HistoryBranchUtilImpl) NewHistoryBranch(

go.temporal.io/server/common/persistence/namespace_replication_queue_mock.go 5 covered LOC · 1 range

Open complete file

31

32 // NewMockNamespaceReplicationQueue creates a new mock instance.

33 > func NewMockNamespaceReplicationQueue(ctrl *gomock.Controller) *MockNamespaceReplicationQueue { namespace_replication_queue_mock.go

34 > mock := &MockNamespaceReplicationQueue{ctrl: ctrl}

35 > mock.recorder = &MockNamespaceReplicationQueueMockRecorder{mock}

36 > return mock

37 > }

38

39 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/plugin.go 5 covered LOC · 1 range

Open complete file

24 var _ sqlplugin.Plugin = (*plugin)(nil)

25

26 > func init() { plugin.go

27 > sql.RegisterPlugin(PluginName, &plugin{

28 > queryConverter: &queryConverter{},

29 > })

30 > }

31

32 func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/conn_pool.go 5 covered LOC · 1 range

Open complete file

23 }

24

25 > func newConnPool() *connPool { conn_pool.go

26 > return &connPool{

27 > pool: make(map[string]entry),

28 > }

29 > }

30

31 // Allocate allocates the shared database in the pool or returns already exists instance with the same DSN. If instance

go.temporal.io/server/common/persistence/visibility/manager/visibility_manager_mock.go 5 covered LOC · 1 range

Open complete file

32

33 // NewMockVisibilityManager creates a new mock instance.

34 > func NewMockVisibilityManager(ctrl *gomock.Controller) *MockVisibilityManager { visibility_manager_mock.go

35 > mock := &MockVisibilityManager{ctrl: ctrl}

36 > mock.recorder = &MockVisibilityManagerMockRecorder{mock}

37 > return mock

38 > }

39

40 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/persistence/visibility/store/elasticsearch/client/client_mock.go 5 covered LOC · 1 range

Open complete file

32

33 // NewMockClient creates a new mock instance.

34 > func NewMockClient(ctrl *gomock.Controller) *MockClient { client_mock.go

35 > mock := &MockClient{ctrl: ctrl}

36 > mock.recorder = &MockClientMockRecorder{mock}

37 > return mock

38 > }

39

40 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/sdk/factory_mock.go 5 covered LOC · 1 range

Open complete file

31

32 // NewMockClientFactory creates a new mock instance.

33 > func NewMockClientFactory(ctrl *gomock.Controller) *MockClientFactory { factory_mock.go

34 > mock := &MockClientFactory{ctrl: ctrl}

35 > mock.recorder = &MockClientFactoryMockRecorder{mock}

36 > return mock

37 > }

38

39 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/searchattribute/mapper_mock.go 5 covered LOC · 1 range

Open complete file

84

85 // NewMockMapperProvider creates a new mock instance.

86 > func NewMockMapperProvider(ctrl *gomock.Controller) *MockMapperProvider { mapper_mock.go

87 > mock := &MockMapperProvider{ctrl: ctrl}

88 > mock.recorder = &MockMapperProviderMockRecorder{mock}

89 > return mock

90 > }

91

92 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

32

33 // NewMockWorkflowServiceClient creates a new mock instance.

34 > func NewMockWorkflowServiceClient(ctrl *gomock.Controller) *MockWorkflowServiceClient { service_grpc.pb.mock.go

35 > mock := &MockWorkflowServiceClient{ctrl: ctrl}

36 > mock.recorder = &MockWorkflowServiceClientMockRecorder{mock}

37 > return mock

38 > }

39

40 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/testing/testvars/hash.go 5 covered LOC · 1 range

Open complete file

5 )

6

7 > func hash(s string) uint32 { hash.go

8 > h := fnv.New32a()

9 > _, _ = h.Write([]byte(s))

10 > return h.Sum32()

11 > }

go.temporal.io/server/service/history/chasm_notifier.go 5 covered LOC · 1 range

Open complete file

21

22 // NewChasmNotifier creates a new instance of ChasmNotifier.

23 > func NewChasmNotifier() *ChasmNotifier { chasm_notifier.go

24 > return &ChasmNotifier{

25 > executions: make(map[chasm.ExecutionKey]*subscriptionTracker),

26 > }

27 > }

28

29 // Subscribe returns a channel that will be closed when there is a notification relating to the

go.temporal.io/server/service/history/events/events_cache_mock.go 5 covered LOC · 1 range

Open complete file

31

32 // NewMockCache creates a new mock instance.

33 > func NewMockCache(ctrl *gomock.Controller) *MockCache { events_cache_mock.go

34 > mock := &MockCache{ctrl: ctrl}

35 > mock.recorder = &MockCacheMockRecorder{mock}

36 > return mock

37 > }

38

39 // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/cache/size_getter.go 4 covered LOC · 2 ranges

Open complete file

14 )

15

16 > func getSize(value any) int { size_getter.go

17 > if v, ok := value.(SizeGetter); ok {

18 > return v.CacheSize() size_getter.go

19 > }

20 // if the object does not have a CacheSize() method, assume is count limit cache, which size should be 1

21 return 1

go.temporal.io/server/common/metrics/config.go 4 covered LOC · 2 ranges

Open complete file

493 }

494

495 > func configExcludeTags(cfg ClientConfig) map[string]map[string]struct{} { config.go

496 > tagsToFilter := make(map[string]map[string]struct{})

497 > for key, val := range cfg.ExcludeTags {

498 exclusions := make(map[string]struct{})

499 for _, val := range val {

502 tagsToFilter[key] = exclusions

503 }

504 > return tagsToFilter config.go

505 }

506

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/typeconv.go 4 covered LOC · 2 ranges

Open complete file

33 }

34

35 > func getMinMySQLDateTime() time.Time { typeconv.go

36 > t, err := time.Parse(time.RFC3339, "1000-01-01T00:00:00Z")

37 > if err != nil {

38 return time.Unix(0, 0).UTC()

39 }

40 > return t.UTC() typeconv.go

41 }

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/typeconv.go 4 covered LOC · 2 ranges

Open complete file

35 }

36

37 > func getMinPostgreSQLDateTime() time.Time { typeconv.go

38 > t, err := time.Parse(time.RFC3339, "1000-01-01T00:00:00Z")

39 > if err != nil {

40 return time.Unix(0, 0).UTC()

41 }

42 > return t.UTC() typeconv.go

43 }

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/typeconv.go 4 covered LOC · 2 ranges

Open complete file

33 }

34

35 > func getMinSQLiteDateTime() time.Time { typeconv.go

36 > t, err := time.Parse(time.RFC3339, "1000-01-01T00:00:00Z")

37 > if err != nil {

38 return time.Unix(0, 0).UTC()

39 }

40 > return t.UTC() typeconv.go

41 }

go.temporal.io/server/service/history/workflow/mutable_state_util.go 4 covered LOC · 2 ranges

Open complete file

16 inputs map[int64]struct{},

17 targetClusters []string,

18 > ) []tasks.Task { mutable_state_util.go

19 > outputs := make([]tasks.Task, 0, len(inputs))

20 > for item := range inputs {

21 activityInfo, ok := activityInfos[item]

22 if ok {

30 }

31 }

32 > return outputs mutable_state_util.go

33 }

34

go.temporal.io/server/service/history/workflow/timeskipping.go 4 covered LOC · 2 ranges

Open complete file

433 ctx context.Context,

434 transactionPolicy historyi.TransactionPolicy,

435 > ) (needRegenTasks bool) { timeskipping.go

436 > if !ms.IsWorkflow() {

437 > return false timeskipping.go

438 > }

439 switch transactionPolicy {

440 case historyi.TransactionPolicyActive:

go.temporal.io/server/service/history/workflow/util.go 4 covered LOC · 2 ranges

Open complete file

130 verifyChecksum func(string) error,

131 autoResetPoints *workflowpb.ResetPoints,

132 > ) (string, *workflowpb.ResetPointInfo) { util.go

133 > if autoResetPoints == nil {

134 > return "", nil util.go

135 > }

136 now := timeSource.Now()

137 for _, p := range autoResetPoints.Points {

go.temporal.io/server/api/persistence/v1/chasm.go-helpers.pb.go 3 covered LOC · 1 range

Open complete file

17

18 // Size returns the size of the object, in bytes, once serialized

19 > func (val *ChasmNode) Size() int { chasm.go-helpers.pb.go

20 > return proto.Size(val)

21 > }

22

23 // Equal returns whether two ChasmNode values are equivalent by recursively

go.temporal.io/server/api/persistence/v1/predicates.go-helpers.pb.go 3 covered LOC · 1 range

Open complete file

17

18 // Size returns the size of the object, in bytes, once serialized

19 > func (val *Predicate) Size() int { predicates.go-helpers.pb.go

20 > return proto.Size(val)

21 > }

22

23 // Equal returns whether two Predicate values are equivalent by recursively

go.temporal.io/server/common/dynamicconfig/key.go 3 covered LOC · 1 range

Open complete file

13 )

14

15 > func MakeKey(s string) Key { key.go

16 > return Key{handle: unique.Make(strings.ToLower(s))}

17 > }

18

19 func (k Key) String() string {

go.temporal.io/server/common/log/noop_logger.go 3 covered LOC · 1 range

Open complete file

10

11 // NewNoopLogger return a noopLogger

12 > func NewNoopLogger() *noopLogger { noop_logger.go

13 > return &noopLogger{}

14 > }

15

16 func (n *noopLogger) Debug(string, ...tag.Tag) {}

go.temporal.io/server/common/membership/hostinfo.go 3 covered LOC · 1 range

Open complete file

12

13 // NewHostInfoFromAddress creates a new HostInfo instance from a socket address.

14 > func NewHostInfoFromAddress(address string) HostInfo { hostinfo.go

15 > return hostAddress(address)

16 > }

17

18 // hostAddress is a HostInfo implementation that uses a string as the address and identity.

go.temporal.io/server/common/metrics/metrics.go 3 covered LOC · 3 ranges

Open complete file

80 )

81

82 > func (c CounterFunc) Record(v int64, tags ...Tag) { c(v, tags...) } metrics.go

83 > func (c GaugeFunc) Record(v float64, tags ...Tag) { c(v, tags...) } metrics.go

84 > func (c TimerFunc) Record(v time.Duration, tags ...Tag) { c(v, tags...) } metrics.go

85 func (c HistogramFunc) Record(v int64, tags ...Tag) { c(v, tags...) }

go.temporal.io/server/common/payload/payload.go 3 covered LOC · 1 range

Open complete file

30 }

31

32 > func Encode(value any) (*commonpb.Payload, error) { payload.go

33 > return defaultDataConverter.ToPayload(value)

34 > }

35

36 func Decode(p *commonpb.Payload, valuePtr any) error {

go.temporal.io/server/common/persistence/nosql/nosqlplugin/cassandra/translator/translator_plugin.go 3 covered LOC · 1 range

Open complete file

22 // RegisterPlugin adds an auth plugin to the plugin registry

23 // it is only safe to use from a package init function

24 > func RegisterTranslator(name string, plugin TranslatorPlugin) { translator_plugin.go

25 > translators[name] = plugin

26 > }

27

28 func LookupTranslator(name string) (TranslatorPlugin, error) {

go.temporal.io/server/common/persistence/persistence_rate_limited_clients.go 3 covered LOC · 1 range

Open complete file

1182 baseAPI string,

1183 taskCategory tasks.Category,

1184 > ) string { persistence_rate_limited_clients.go

1185 > return baseAPI + taskCategory.Name()

1186 > }

go.temporal.io/server/common/persistence/serialization/serializer.go 3 covered LOC · 1 range

Open complete file

139 )

140

141 > func NewSerializer() Serializer { serializer.go

142 > return &serializerImpl{encodingType: encodingTypeFromEnv()}

143 > }

144

145 func (t *serializerImpl) EncodingType() enumspb.EncodingType {

go.temporal.io/server/common/persistence/sql/store.go 3 covered LOC · 2 ranges

Open complete file

19

20 // RegisterPlugin will register a SQL plugin

21 > func RegisterPlugin(pluginName string, plugin sqlplugin.Plugin) { store.go

22 > if _, ok := supportedPlugins[pluginName]; ok {

23 panic("plugin " + pluginName + " already registered")

24 }

25 > supportedPlugins[pluginName] = plugin store.go

26 }

27

go.temporal.io/server/common/persistence/versionhistory/version_history.go 3 covered LOC · 1 range

Open complete file

248

249 // IsEmptyVersionHistory indicate whether version history is empty

250 > func IsEmptyVersionHistory(v *historyspb.VersionHistory) bool { version_history.go

251 > return len(v.Items) == 0

252 > }

253

254 // CompareVersionHistory compares 2 version history items

go.temporal.io/server/common/softassert/softassert.go 3 covered LOC · 2 ranges

Open complete file

26 // Example:

27 // softassert.That(logger, object.state == "ready", "object is not ready")

28 > func That(logger log.Logger, condition bool, staticMessage string, tags ...tag.Tag) bool { softassert.go

29 > if !condition {

30 // By using the same prefix for all assertions, they can be reliably found in logs.

31 logger.Error("failed assertion: "+staticMessage, append([]tag.Tag{tag.FailedAssertion}, tags...)...)

32 }

33 > return condition softassert.go

34 }

35

go.temporal.io/server/common/testing/protorequire/require.go 3 covered LOC · 1 range

Open complete file

38 }

39

40 > func New(t require.TestingT) ProtoAssertions { require.go

41 > return ProtoAssertions{t}

42 > }

43

44 // ProtoEqual compares two proto messages for equality using proto semantics. Options can be passed to customize

go.temporal.io/server/service/history/queues/errors/errors.go 3 covered LOC · 1 range

Open complete file

39

40 // NewUnprocessableTaskError returns a new UnprocessableTaskError from given message.

41 > func NewUnprocessableTaskError(message string) *UnprocessableTaskError { errors.go

42 > return &UnprocessableTaskError{Message: message}

43 > }

44

45 func (e UnprocessableTaskError) Error() string {

go.temporal.io/server/common/persistence/client/fx.go 2 covered LOC · 1 range

Open complete file

224 }

225

226 > func managerProvider[T persistence.Closeable](newManagerFn func(Factory) (T, error)) func(Factory, fx.Lifecycle) (T, error) { fx.go

227 > return func(f Factory, lc fx.Lifecycle) (T, error) {

228 manager, err := newManagerFn(f) // passing receiver (Factory) as first argument.

229 if err != nil {

go.temporal.io/server/common/aggregate/noop_moving_window_average.go 1 covered LOC · 1 range

Open complete file

7 )

8

9 > func newNoopMovingWindowAverage() *noopMovingWindowAverage { return &noopMovingWindowAverage{} } noop_moving_window_average.go

10

11 func (a *noopMovingWindowAverage) Record(_ int64) {}

go.temporal.io/server/common/persistence/noop_health_signal_aggregator.go 1 covered LOC · 1 range

Open complete file

11 )

12

13 > func newNoopSignalAggregator() *noopSignalAggregator { return &noopSignalAggregator{} } noop_health_signal_aggregator.go

14

15 func (a *noopSignalAggregator) Start() {}