TestRebuild

go.temporal.io/server/service/history/workflow/mutable_state_impl.go 825 covered LOC · 211 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(

426 shard.ChasmRegistry(),

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

1024 runTimeout *durationpb.Duration,

1025 treeID string,

1026 > ) error { mutable_state_impl.go

1027 > // NOTE: Unfortunately execution timeout and run timeout are not yet initialized into ms.executionInfo at this point.

1028 > // TODO: Consider explicitly initializing mutable state with these timeout parameters instead of passing them in.

1029 > workflowKey := ms.GetWorkflowKey()

1030 >

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

1032 > if archetypeID != chasm.WorkflowArchetypeID {

1033 return softassert.UnexpectedInternalErr(

1034 ms.logger,

1042 }

1043

1044 > var retentionDuration *durationpb.Duration mutable_state_impl.go

1045 > if duration := ms.namespaceEntry.Retention(); duration > 0 {

1046 retentionDuration = durationpb.New(duration)

1047 }

1048 > initialBranchToken, err := ms.shard.GetExecutionManager().GetHistoryBranchUtil().NewHistoryBranch( mutable_state_impl.go

1049 > workflowKey.NamespaceID,

1050 > workflowKey.WorkflowID,

1051 > workflowKey.RunID,

1052 > treeID,

1053 > nil,

1054 > []*persistencespb.HistoryBranchRange{},

1055 > runTimeout.AsDuration(),

1056 > executionTimeout.AsDuration(),

1057 > retentionDuration.AsDuration(),

1058 > )

1059 > if err != nil {

1060 return err

1061 }

1062 > return ms.SetCurrentBranchToken(initialBranchToken) mutable_state_impl.go

1063 }

1064

1065 func (ms *MutableStateImpl) SetCurrentBranchToken(

1066 branchToken []byte,

1067 > ) error { mutable_state_impl.go

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

1069 > if err != nil {

1070 return err

1071 }

1072 > versionhistory.SetVersionHistoryBranchToken(currentVersionHistory, branchToken) mutable_state_impl.go

1073 > return nil

1074 }

1075

1076 > func (ms *MutableStateImpl) SetHistoryBuilder(hBuilder *historybuilder.HistoryBuilder) { mutable_state_impl.go

1077 > ms.hBuilder = hBuilder

1078 > }

1079

1080 func (ms *MutableStateImpl) SetBaseWorkflow(

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() {

1138 version int64,

1139 forceUpdate bool,

1140 > ) error { mutable_state_impl.go

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

1142 // this make sure current version >= last write version

1143 lastVersionedTransition := ms.CurrentVersionedTransition()

1144 ms.currentVersion = lastVersionedTransition.NamespaceFailoverVersion

1145 > } else { mutable_state_impl.go

1146 > versionHistory, err := versionhistory.GetCurrentVersionHistory(ms.executionInfo.VersionHistories) mutable_state_impl.go

1147 > if err != nil {

1148 return err

1149 }

1150

1151 > if !versionhistory.IsEmptyVersionHistory(versionHistory) { mutable_state_impl.go

1152 > // this make sure current version >= last event version mutable_state_impl.go

1153 > versionHistoryItem, err := versionhistory.GetLastVersionHistoryItem(versionHistory)

1154 > if err != nil {

1155 return err

1156 }

1157 > ms.currentVersion = versionHistoryItem.GetVersion() mutable_state_impl.go

1158 }

1159 }

1160

1161 > if version > ms.currentVersion || forceUpdate { mutable_state_impl.go

1162 > ms.currentVersion = version mutable_state_impl.go

1163 > }

1164

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

1166 > ms.timeSource,

1167 > ms.shard.GenerateTaskIDs,

1168 > ms.currentVersion,

1169 > ms.nextEventIDInDB,

1170 > ms.bufferEventsInDB,

1171 > ms.metricsHandler,

1172 > ms.config.MaximumEventBatchSizeInBytes,

1173 > )

1174 >

1175 > return nil

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 {

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.

1376 // GenerateEventLoadToken calls should reference. Only needed during replay. The rebuilder sets it

1377 // for each batch before applying its events.

1378 > func (ms *MutableStateImpl) SetReplayEventBatchID(batchID int64) { mutable_state_impl.go

1379 > ms.replayEventBatchID = batchID

1380 > }

1381

1382 // GenerateEventLoadToken generates a token for loading a history event at a later time. The token encodes the event ID

1448 }

1449

1450 > func (ms *MutableStateImpl) ClearStickyTaskQueue() { mutable_state_impl.go

1451 > ms.executionInfo.StickyTaskQueue = ""

1452 > ms.executionInfo.StickyScheduleToStartTimeout = nil

1453 > }

1454

1455 func (ms *MutableStateImpl) IsStickyTaskQueueSet() bool {

1485 }

1486

1487 > func (ms *MutableStateImpl) GetWorkflowType() *commonpb.WorkflowType { mutable_state_impl.go

1488 > wType := &commonpb.WorkflowType{}

1489 > wType.Name = ms.executionInfo.WorkflowTypeName

1490 >

1491 > return wType

1492 > }

1493

1494 func (ms *MutableStateImpl) GetQueryRegistry() historyi.QueryRegistry {

1916 }

1917

1918 > func (ms *MutableStateImpl) Now() time.Time { mutable_state_impl.go

1919 > return ms.timeSource.Now()

1920 > }

1921

1922 // GetWorkflowCloseTime returns workflow closed time, returns a zero time for open workflow

2071 func (ms *MutableStateImpl) writeEventToCache(

2072 event *historypb.HistoryEvent,

2073 > ) { mutable_state_impl.go

2074 > // For start event: store it here so the recordWorkflowStarted transfer task doesn't need to

2075 > // load it from database.

2076 > // For completion event: store it here so we can communicate the result to parent execution

2077 > // during the processing of DeleteTransferTask without loading this event from database.

2078 > // For Update events: store it here so that Update disposition lookups can be fast.

2079 > ms.eventsCache.PutEvent(

2080 > events.EventKey{

2081 > NamespaceID: namespace.ID(ms.executionInfo.NamespaceId),

2082 > WorkflowID: ms.executionInfo.WorkflowId,

2083 > RunID: ms.executionState.RunId,

2084 > EventID: event.GetEventId(),

2085 > Version: event.GetVersion(),

2086 > },

2087 > event,

2088 > )

2089 > }

2090

2091 func (ms *MutableStateImpl) HasParentExecution() bool {

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:

2485 return true

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

2969 requestID string,

2970 startEvent *historypb.HistoryEvent,

2971 > ) error { mutable_state_impl.go

2972 > if ms.executionInfo.NamespaceId != ms.namespaceEntry.ID().String() {

2973 return serviceerror.NewInternalf("applying conflicting namespace ID: %v != %v",

2974 ms.executionInfo.NamespaceId, ms.namespaceEntry.ID().String())

2975 }

2976 > if ms.executionInfo.WorkflowId != execution.GetWorkflowId() { mutable_state_impl.go

2977 return serviceerror.NewInternalf("applying conflicting workflow ID: %v != %v",

2978 ms.executionInfo.WorkflowId, execution.GetWorkflowId())

2979 }

2980 > if ms.executionState.RunId != execution.GetRunId() { mutable_state_impl.go

2981 return serviceerror.NewInternalf("applying conflicting run ID: %v != %v",

2982 ms.executionState.RunId, execution.GetRunId())

2983 }

2984

2985 > event := startEvent.GetWorkflowExecutionStartedEventAttributes() mutable_state_impl.go

2986 > ms.AttachRequestID(requestID, startEvent.EventType, startEvent.EventId)

2987 >

2988 > ms.approximateSize -= ms.executionInfo.Size()

2989 > ms.executionInfo.FirstExecutionRunId = event.GetFirstExecutionRunId()

2990 > ms.executionInfo.TaskQueue = event.TaskQueue.GetName()

2991 > ms.executionInfo.WorkflowTypeName = event.WorkflowType.GetName()

2992 > ms.executionInfo.WorkflowRunTimeout = event.GetWorkflowRunTimeout()

2993 > ms.executionInfo.WorkflowExecutionTimeout = event.GetWorkflowExecutionTimeout()

2994 > ms.executionInfo.DefaultWorkflowTaskTimeout = event.GetWorkflowTaskTimeout()

2995 > ms.executionInfo.OriginalExecutionRunId = event.GetOriginalExecutionRunId()

2996 >

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

2998 > ms.executionState.FirstExecutionRunId = event.GetFirstExecutionRunId()

2999 > if err := ms.addCompletionCallbacks(

3000 > startEvent,

3001 > requestID,

3002 > event.GetCompletionCallbacks(),

3003 > ); err != nil {

3004 return err

3005 }

3006 > if _, err := ms.UpdateWorkflowStateStatus( mutable_state_impl.go

3007 > enumsspb.WORKFLOW_EXECUTION_STATE_CREATED,

3008 > enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING,

3009 > ); err != nil {

3010 return err

3011 }

3012 > ms.executionInfo.LastCompletedWorkflowTaskStartedEventId = common.EmptyEventID mutable_state_impl.go

3013 > ms.executionInfo.LastFirstEventId = startEvent.GetEventId()

3014 >

3015 > ms.executionInfo.WorkflowTaskVersion = common.EmptyVersion

3016 > ms.executionInfo.WorkflowTaskScheduledEventId = common.EmptyEventID

3017 > ms.executionInfo.WorkflowTaskStartedEventId = common.EmptyEventID

3018 > ms.executionInfo.WorkflowTaskRequestId = emptyUUID

3019 > ms.executionInfo.WorkflowTaskTimeout = timestamp.DurationFromSeconds(0)

3020 >

3021 > ms.executionInfo.CronSchedule = event.GetCronSchedule()

3022 >

3023 > if event.ParentWorkflowExecution != nil {

3024 ms.executionInfo.ParentNamespaceId = event.GetParentWorkflowNamespaceId()

3025 ms.executionInfo.ParentWorkflowId = event.ParentWorkflowExecution.GetWorkflowId()

3028 }

3029

3030 > if event.ParentInitiatedEventId != 0 { mutable_state_impl.go

3031 ms.executionInfo.ParentInitiatedId = event.GetParentInitiatedEventId()

3032 > } else { mutable_state_impl.go

3033 > ms.executionInfo.ParentInitiatedId = common.EmptyEventID mutable_state_impl.go

3034 > }

3035

3036 > if event.ParentInitiatedEventVersion != 0 { mutable_state_impl.go

3037 ms.executionInfo.ParentInitiatedVersion = event.GetParentInitiatedEventVersion()

3038 > } else { mutable_state_impl.go

3039 > ms.executionInfo.ParentInitiatedVersion = common.EmptyVersion mutable_state_impl.go

3040 > }

3041

3042 > if event.RootWorkflowExecution != nil { mutable_state_impl.go

3043 ms.executionInfo.RootWorkflowId = event.RootWorkflowExecution.GetWorkflowId()

3044 ms.executionInfo.RootRunId = event.RootWorkflowExecution.GetRunId()

3045 > } else { mutable_state_impl.go

3046 > ms.executionInfo.RootWorkflowId = execution.GetWorkflowId()

3047 > ms.executionInfo.RootRunId = execution.GetRunId()

3048 > }

3049

3050 // todo@time-skipping: apply time skipping to WorkflowStartDelay

3051 > ms.executionInfo.ExecutionTime = timestamppb.New( mutable_state_impl.go

3052 > ms.executionState.StartTime.AsTime().Add(event.GetFirstWorkflowTaskBackoff().AsDuration()),

3053 > )

3054 >

3055 > ms.executionInfo.Attempt = event.GetAttempt()

3056 > if !timestamp.TimeValue(event.GetWorkflowExecutionExpirationTime()).IsZero() {

3057 ms.executionInfo.WorkflowExecutionExpirationTime = event.GetWorkflowExecutionExpirationTime()

3058 }

3059

3060 > var workflowRunTimeoutTime time.Time mutable_state_impl.go

3061 > workflowRunTimeoutDuration := ms.executionInfo.WorkflowRunTimeout.AsDuration()

3062 > // if workflowRunTimeoutDuration == 0 then the workflowRunTimeoutTime will be 0

3063 > // meaning that there is not workflow run timeout

3064 > if workflowRunTimeoutDuration != 0 {

3065 > firstWorkflowTaskDelayDuration := event.GetFirstWorkflowTaskBackoff().AsDuration() mutable_state_impl.go

3066 > workflowRunTimeoutDuration = workflowRunTimeoutDuration + firstWorkflowTaskDelayDuration

3067 > workflowRunTimeoutTime = ms.executionState.StartTime.AsTime().Add(workflowRunTimeoutDuration)

3068 >

3069 > workflowExecutionTimeoutTime := timestamp.TimeValue(ms.executionInfo.WorkflowExecutionExpirationTime)

3070 > if !workflowExecutionTimeoutTime.IsZero() && workflowRunTimeoutTime.After(workflowExecutionTimeoutTime) {

3071 workflowRunTimeoutTime = workflowExecutionTimeoutTime

3072 }

3073 }

3074 > ms.executionInfo.WorkflowRunExpirationTime = timestamppb.New(workflowRunTimeoutTime) mutable_state_impl.go

3075 >

3076 > if event.RetryPolicy != nil {

3077 ms.executionInfo.HasRetryPolicy = true

3078 ms.executionInfo.RetryBackoffCoefficient = event.RetryPolicy.GetBackoffCoefficient()

3083 }

3084

3085 > ms.executionInfo.AutoResetPoints = rolloverAutoResetPointsWithExpiringTime( mutable_state_impl.go

3086 > event.GetPrevAutoResetPoints(),

3087 > event.GetContinuedExecutionRunId(),

3088 > timestamp.TimeValue(startEvent.GetEventTime()),

3089 > ms.namespaceEntry.Retention(),

3090 > )

3091 >

3092 > if event.Memo != nil {

3093 ms.executionInfo.Memo = event.Memo.GetFields()

3094 }

3095 > if event.SearchAttributes != nil { mutable_state_impl.go

3096 ms.executionInfo.SearchAttributes = event.SearchAttributes.GetIndexedFields()

3097 }

3098

3099 > if event.GetVersioningOverride() != nil { mutable_state_impl.go

3100 if ms.executionInfo.VersioningInfo == nil {

3101 ms.executionInfo.VersioningInfo = &workflowpb.WorkflowExecutionVersioningInfo{}

3136 }

3137

3138 > if event.GetInheritedPinnedVersion() != nil { mutable_state_impl.go

3139 if ms.executionInfo.VersioningInfo == nil {

3140 ms.executionInfo.VersioningInfo = &workflowpb.WorkflowExecutionVersioningInfo{}

3147 // target version upgrade from the started event. This is the same public API

3148 // type, so no conversion needed.

3149 > if event.GetContinuedExecutionRunId() != "" && event.GetInheritedPinnedVersion() != nil { mutable_state_impl.go

3150 ms.executionInfo.DeclinedTargetVersionUpgrade = event.GetDeclinedTargetVersionUpgrade()

3151 }

3152

3153 // Populate the versioningInfo if the inheritedAutoUpgradeInfo is present.

3154 > if event.GetInheritedAutoUpgradeInfo() != nil { mutable_state_impl.go

3155 ms.SetVersioningRevisionNumber(event.GetInheritedAutoUpgradeInfo().GetSourceDeploymentRevisionNumber())

3156 // TODO (Shivam): Remove this once you make SetDeploymentVersion and SetVersioningBehavior methods with nil checks

3164 }

3165

3166 > if inheritedBuildId := event.InheritedBuildId; inheritedBuildId != "" { mutable_state_impl.go

3167 ms.executionInfo.InheritedBuildId = inheritedBuildId

3168 if err := ms.UpdateBuildIdAssignment(inheritedBuildId); err != nil {

3169 return err

3170 }

3171 > } else if event.SourceVersionStamp.GetUseVersioning() && event.SourceVersionStamp.GetBuildId() != "" || mutable_state_impl.go

3172 > ms.GetEffectiveVersioningBehavior() != enumspb.VERSIONING_BEHAVIOR_UNSPECIFIED {

3173 // TODO: [cleanup-old-wv]

3174 limit := ms.config.SearchAttributesSizeOfValueLimit(string(ms.namespaceEntry.Name()))

3181

3182 // This will include override and inheritance, but not transition, because WF never starts with a transition

3183 > ms.executionInfo.WorkerDeploymentName = ms.GetEffectiveDeployment().GetSeriesName() mutable_state_impl.go

3184 >

3185 > if inheritedBuildId := event.InheritedBuildId; inheritedBuildId != "" {

3186 ms.executionInfo.InheritedBuildId = inheritedBuildId

3187 if err := ms.UpdateBuildIdAssignment(inheritedBuildId); err != nil {

3190 }

3191

3192 > ms.executionInfo.MostRecentWorkerVersionStamp = event.SourceVersionStamp mutable_state_impl.go

3193 > ms.executionInfo.Priority = event.Priority

3194 >

3195 > if tsc, stateProp := event.GetTimeSkippingConfig(), event.GetTimeSkippingStatePropagation(); tsc != nil || stateProp.GetInitialSkippedDuration().AsDuration() > 0 {

3196 if err := ms.initTimeSkippingInfo(tsc, stateProp); err != nil {

3197 return err

3199 }

3200

3201 > ms.approximateSize += ms.executionInfo.Size() mutable_state_impl.go

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

3203 >

3204 > ms.writeEventToCache(startEvent)

3205 > return nil

3206 }

3207

3386 requestID string,

3387 completionCallbacks []*commonpb.Callback,

3388 > ) error { mutable_state_impl.go

3389 > if len(completionCallbacks) == 0 {

3390 > return nil mutable_state_impl.go

3391 > }

3392 if ms.chasmCallbacksEnabled() {

3393 // Initialize chasm tree once for new workflows.

6152 func (ms *MutableStateImpl) ApplyWorkflowExecutionSignaled(

6153 event *historypb.HistoryEvent,

6154 > ) error { mutable_state_impl.go

6155 > // Increment signal count in mutable state for this workflow execution

6156 > ms.executionInfo.SignalCount++

6157 >

6158 > // Add signal requestID to workflow CHASM tree (if feature is enabled)

6159 > signalEventAttrs, ok := event.GetAttributes().(*historypb.HistoryEvent_WorkflowExecutionSignaledEventAttributes)

6160 > if !ok {

6161 return softassert.UnexpectedInternalErr(

6162 ms.logger,

6168 )

6169 }

6170 > requestID := signalEventAttrs.WorkflowExecutionSignaledEventAttributes.GetRequestId() mutable_state_impl.go

6171 > if requestID != "" && ms.ChasmSignalBacklinksEnabled() {

6172 ctx := context.Background()

6173 ms.EnsureChasmWorkflowComponent(ctx)

6185 metrics.ChasmIncomingSignalWritten.With(ms.metricsHandler.WithTags(nsTag)).Record(1)

6186 }

6187 > return nil mutable_state_impl.go

6188 }

6189

6305 newExecutionStartTime time.Time,

6306 namespaceRetention time.Duration,

6307 > ) *workflowpb.ResetPoints { mutable_state_impl.go

6308 > if resetPoints.GetPoints() == nil {

6309 > return resetPoints

6310 > }

6311 newPoints := make([]*workflowpb.ResetPointInfo, 0, len(resetPoints.Points))

6312 // For continue-as-new, new execution start time is the same as previous execution close time,

7140 }

7141

7142 > func (ms *MutableStateImpl) AddExternalPayloadSize(size int64) { mutable_state_impl.go

7143 > if ms.executionInfo.ExecutionStats == nil {

7144 ms.executionInfo.ExecutionStats = &persistencespb.ExecutionStats{}

7145 }

7146 > ms.executionInfo.ExecutionStats.ExternalPayloadSize += size mutable_state_impl.go

7147 }

7148

7151 }

7152

7153 > func (ms *MutableStateImpl) AddExternalPayloadCount(count int64) { mutable_state_impl.go

7154 > if ms.executionInfo.ExecutionStats == nil {

7155 ms.executionInfo.ExecutionStats = &persistencespb.ExecutionStats{}

7156 }

7157 > ms.executionInfo.ExecutionStats.ExternalPayloadCount += count mutable_state_impl.go

7158 }

7159

7254 func (ms *MutableStateImpl) AddTasks(

7255 newTasks ...tasks.Task,

7256 > ) { mutable_state_impl.go

7257 > now := ms.Now()

7258 > for _, task := range newTasks {

7259 > if chasmTask, ok := task.(*tasks.ChasmTask); ok &&

7260 > chasmTask.GetCategory() == tasks.CategoryVisibility &&

7261 > ms.stateInDB == enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED {

7262 softassert.Fail(ms.logger, "CHASM visibility task added on already-closed execution")

7263 }

7264

7265 > category := task.GetCategory() mutable_state_impl.go

7266 > // Drop tasks scheduled too far in the future. VisibilityTime hasn't been

7267 > // shifted to wall-clock yet (the conversion runs below), so both sides are

7268 > // virtual here; the difference is frame-invariant (skip cancels). Keep

7269 > // `now` from ms.Now() so both stay in the same frame.

7270 > if category.Type() == tasks.CategoryTypeScheduled &&

7271 > task.GetVisibilityTime().Sub(now) > maxScheduledTaskDuration {

7272 ms.logger.Info("Dropped long duration scheduled task.", tasks.Tags(task)...)

7273 continue

7279 // vs. real distinction. The CategoryTypeScheduled drop-check above runs first so it

7280 // compares virtual-vs-virtual (now is also virtual).

7281 > if category.Type() == tasks.CategoryTypeScheduled { mutable_state_impl.go

7282 > task.SetVisibilityTime(ms.ToRealTime(task.GetVisibilityTime())) mutable_state_impl.go

7283 > }

7284

7285 > if chasmPureTask, ok := task.(*tasks.ChasmTaskPure); ok { mutable_state_impl.go

7286 ms.chasmPureTasks = append(ms.chasmPureTasks, chasmPureTask)

7287 maxPureTasks := ms.config.ChasmMaxInMemoryPureTasks()

7296 }

7297

7298 > ms.InsertTasks[category] = append(ms.InsertTasks[category], task) mutable_state_impl.go

7299 }

7300 }

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 mutable_state_impl.go

7396 > }

7397 if state != enumsspb.WORKFLOW_EXECUTION_STATE_ZOMBIE &&

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

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: mutable_state_impl.go

7633 > // Set workflow type

7634 > if wfType := ms.GetWorkflowType(); wfType != nil && wfType.GetName() != "" {

7635 > contextutil.ContextMetadataSet(ctx, contextutil.MetadataKeyWorkflowType, wfType.GetName()) mutable_state_impl.go

7636 > }

7637

7638 // Set workflow task queue

7639 > if ms.executionInfo != nil && ms.executionInfo.TaskQueue != "" { mutable_state_impl.go

7640 > contextutil.ContextMetadataSet(ctx, contextutil.MetadataKeyWorkflowTaskQueue, ms.executionInfo.TaskQueue) mutable_state_impl.go

7641 > }

7642

7643 > for _, activityID := range contextutil.ContextMetadataGetMarkedActivityIDs(ctx) { mutable_state_impl.go

7644 if ai, ok := ms.GetActivityByActivityID(activityID); ok {

7645 contextutil.ContextMetadataSet(ctx, contextutil.ActivityTypeKey(ai.ScheduledEventId), ai.ActivityType.GetName())

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)

7703 for _, we := range workflowEventsSeq {

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()

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

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 mutable_state_impl.go

7822 > }

7823

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

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 mutable_state_impl.go

7851 > }

7852

7853 // It is important to convert speculative WT to normal before prepareEventsAndReplicationTasks,

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 mutable_state_impl.go

7864 > // when not syncing mutable state

7865 > return nil

7866 > }

7867

7868 if !ms.transitionHistoryEnabled {

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 mutable_state_impl.go

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

7892 > return

7893 > }

7894

7895 if !ms.transitionHistoryEnabled {

7950 }

7951

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

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

7954 if transitionhistory.Compare(

7955 ms.versionedTransitionInDB,

7963 // State changed but transition history not updated.

7964 // We are in unknown versioned transition state, clear the transition history.

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

7966 ms.executionInfo.PreviousTransitionHistory = ms.executionInfo.TransitionHistory

7967 ms.executionInfo.LastTransitionHistoryBreakPoint = transitionhistory.CopyVersionedTransition(ms.CurrentVersionedTransition())

7968 }

7969

7970 > ms.executionInfo.TransitionHistory = nil mutable_state_impl.go

7971 >

7972 > ms.executionInfo.SubStateMachineTombstoneBatches = nil

7973 > ms.totalTombstones = 0

7974 >

7975 > for _, activityInfo := range ms.updateActivityInfos {

7976 activityInfo.LastUpdateVersionedTransition = nil

7977 }

7978 > for _, timerInfo := range ms.updateTimerInfos { mutable_state_impl.go

7979 timerInfo.LastUpdateVersionedTransition = nil

7980 }

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

7982 childInfo.LastUpdateVersionedTransition = nil

7983 }

7984 > for _, requestCancelInfo := range ms.updateRequestCancelInfos { mutable_state_impl.go

7985 requestCancelInfo.LastUpdateVersionedTransition = nil

7986 }

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

7988 signalInfo.LastUpdateVersionedTransition = nil

7989 }

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

7991 ms.executionInfo.UpdateInfos[updateID].LastUpdateVersionedTransition = nil

7992 }

7993 > if len(ms.updateSignalRequestedIDs) > 0 || len(ms.deleteSignalRequestedIDs) > 0 { mutable_state_impl.go

7994 ms.executionInfo.SignalRequestIdsLastUpdateVersionedTransition = nil

7995 }

7996 > if ms.visibilityUpdated { mutable_state_impl.go

7997 ms.executionInfo.VisibilityLastUpdateVersionedTransition = nil

7998 }

7999 > if ms.executionStateUpdated { mutable_state_impl.go

8000 ms.executionState.LastUpdateVersionedTransition = nil

8001 }

8002 > if ms.workflowTaskUpdated { mutable_state_impl.go

8003 ms.executionInfo.WorkflowTaskLastUpdateVersionedTransition = nil

8004 }

8005 > if ms.stateMachineNode != nil { mutable_state_impl.go

8006 > // the error must be nil here since the fn passed into Walk() always returns nil

8007 > _ = ms.stateMachineNode.Walk(func(node *hsm.Node) error {

8008 > persistenceRepr := node.InternalRepr()

8009 > persistenceRepr.LastUpdateVersionedTransition.TransitionCount = 0

8010 > persistenceRepr.InitialVersionedTransition.TransitionCount = 0

8011 > return nil

8012 > })

8013 }

8014 }

8017 transactionPolicy historyi.TransactionPolicy,

8018 workflowEventsSeq []*persistence.WorkflowEvents,

8019 > ) { mutable_state_impl.go

8020 > if transactionPolicy != historyi.TransactionPolicyActive {

8021 > return mutable_state_impl.go

8022 > }

8023

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

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 mutable_state_impl.go

8049 > // snapshot or mutation.

8050 > return

8051 > }

8052

8053 if !ms.transitionHistoryEnabled {

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}) mutable_state_impl.go

8247 > if err != nil {

8248 return err

8249 }

8250 > replicationTasks = append(replicationTasks, task...) mutable_state_impl.go

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:

8265 if ms.generateReplicationTask() {

8323 }

8324 }

8325 > case historyi.TransactionPolicyPassive: mutable_state_impl.go

8326 default:

8327 panic(fmt.Sprintf("unknown transaction policy: %v", transactionPolicy))

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()

8386 > } else { mutable_state_impl.go

8387 > ms.versionedTransitionInDB = nil mutable_state_impl.go

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{ mutable_state_impl.go

8439 > NamespaceID: ms.executionInfo.NamespaceId,

8440 > WorkflowID: ms.executionInfo.WorkflowId,

8441 > RunID: ms.executionState.RunId,

8442 > BranchToken: currentBranchToken,

8443 > PrevTxnID: ms.executionInfo.LastFirstEventTxnId,

8444 > TxnID: historyNodeTxnIDs[index],

8445 > Events: eventBatch,

8446 > }

8447 > ms.executionInfo.LastFirstEventId = eventBatch[0].GetEventId()

8448 > ms.executionInfo.LastFirstEventTxnId = historyNodeTxnIDs[index]

8449 >

8450 > // Calculate and add the external payload size and count for this batch

8451 > if ms.config.ExternalPayloadsEnabled(ms.GetNamespaceEntry().Name().String()) {

8452 > externalPayloadSize, externalPayloadCount, err := CalculateExternalPayloadSize(eventBatch, ms.metricsHandler)

8453 > if err != nil {

8454 return nil, nil, nil, false, err

8455 }

8456 > ms.AddExternalPayloadSize(externalPayloadSize) mutable_state_impl.go

8457 > ms.AddExternalPayloadCount(externalPayloadCount)

8458 }

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 mutable_state_impl.go

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

8471 > if err := ms.updateWithLastWriteEvent(

8472 > lastEvent,

8473 > transactionPolicy,

8474 > ); err != nil {

8475 return nil, nil, nil, false, err

8476 }

8477 }

8478

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

8480 }

8481

8483 transactionPolicy historyi.TransactionPolicy,

8484 eventBatches [][]*historypb.HistoryEvent,

8485 > ) ([]tasks.Task, error) { mutable_state_impl.go

8486 > switch transactionPolicy {

8487 case historyi.TransactionPolicyActive:

8488 if ms.generateReplicationTask() {

8490 }

8491 return nil, nil

8492 > case historyi.TransactionPolicyPassive: mutable_state_impl.go

8493 > return nil, nil

8494 default:

8495 panic(fmt.Sprintf("unknown transaction policy: %v", transactionPolicy))

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:

8505 if ms.generateReplicationTask() {

8526 }

8527 return nil

8528 > case historyi.TransactionPolicyPassive: mutable_state_impl.go

8529 > return emptyTasks

8530 default:

8531 panic(fmt.Sprintf("unknown transaction policy: %v", transactionPolicy))

8537 eventBatches [][]*historypb.HistoryEvent,

8538 clearBufferEvents bool,

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

8540 > switch transactionPolicy {

8541 case historyi.TransactionPolicyActive:

8542 if !ms.generateReplicationTask() {

8568

8569 return emptyTasks

8570 > case historyi.TransactionPolicyPassive: mutable_state_impl.go

8571 > return emptyTasks

8572 default:

8573 panic(fmt.Sprintf("unknown transaction policy: %v", transactionPolicy))

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

8621 lastEvent *historypb.HistoryEvent,

8622 transactionPolicy historyi.TransactionPolicy,

8623 > ) error { mutable_state_impl.go

8624 > if transactionPolicy == historyi.TransactionPolicyPassive {

8625 > // already handled in mutable state. mutable_state_impl.go

8626 > return nil

8627 > }

8628

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

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:

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

8819 }

8820 return nil

8821 > case historyi.TransactionPolicyPassive: mutable_state_impl.go

8822 > return nil

8823 default:

8824 panic(fmt.Sprintf("unknown transaction policy: %v", transactionPolicy))

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 mutable_state_impl.go

8845 > }

8846

8847 if ms.BufferSizeAcceptable() {

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 mutable_state_impl.go

8876 > }

8877

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

8902 func (ms *MutableStateImpl) closeTransactionHandleActivityUserTimerTasks(

8903 transactionPolicy historyi.TransactionPolicy,

8904 > ) error { mutable_state_impl.go

8905 > switch transactionPolicy {

8906 case historyi.TransactionPolicyActive:

8907 if !ms.IsWorkflowExecutionRunning() {

8912 }

8913 return ms.taskGenerator.GenerateUserTimerTasks()

8914 > case historyi.TransactionPolicyPassive: mutable_state_impl.go

8915 > return nil

8916 default:

8917 panic(fmt.Sprintf("unknown transaction policy: %v", transactionPolicy))

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

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

9603 //

9604 // Note: Deployment objects are immutable, never change their fields.

9605 > func (ms *MutableStateImpl) GetEffectiveDeployment() *deploymentpb.Deployment { mutable_state_impl.go

9606 > return GetEffectiveDeployment(ms.GetExecutionInfo().GetVersioningInfo())

9607 > }

9608

9609 func (ms *MutableStateImpl) GetWorkerDeploymentSA() string {

9672 // 3. Behavior: this is returned when there is no override (most common case). Behavior is

9673 // set based on the worker-sent deployment in the latest WFT completion.

9674 > func (ms *MutableStateImpl) GetEffectiveVersioningBehavior() enumspb.VersioningBehavior { mutable_state_impl.go

9675 > return GetEffectiveVersioningBehavior(ms.GetExecutionInfo().GetVersioningInfo())

9676 > }

9677

9678 // StartDeploymentTransition starts a transition to the given deployment which must be

9923 }

9924

9925 > func (ms *MutableStateImpl) ToRealTime(virtualTime time.Time) time.Time { mutable_state_impl.go

9926 > if virtualTime.IsZero() {

9927 return virtualTime

9928 }

9929 > return virtualTime.Add(-ms.accumulatedSkippedDuration()) mutable_state_impl.go

9930 }

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/shard/context_impl.go 157 covered LOC · 34 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 {

227 }

228

229 > func (s *ContextImpl) GetExecutionManager() persistence.ExecutionManager { context_impl.go

230 > // constant from initialization, no need for locks

231 > return s.executionManager

232 > }

233

234 func (s *ContextImpl) GetPingChecks() []pingable.Check {

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) {

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() context_impl.go

341 > if err != nil {

342 return nil, err

343 }

344 > result = append(result, id) context_impl.go

345 }

346 > return result, nil context_impl.go

347 }

348

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 {

1150 }

1151

1152 > func (s *ContextImpl) generateTaskIDLocked() (int64, error) { context_impl.go

1153 > taskKey, err := s.taskKeyManager.generateTaskKey(tasks.CategoryTransfer)

1154 > if err != nil {

1155 return -1, err

1156 }

1157 > return taskKey.TaskID, nil context_impl.go

1158 }

1159

1469

1470 // FinishStop should only be called by the controller.

1471 > func (s *ContextImpl) FinishStop() { context_impl.go

1472 > // After this returns, engineFuture.Set may not be called anymore, so if we don't get see

1473 > // an Engine here, we won't ever have one.

1474 > _ = s.transition(contextRequestFinishStop{})

1475 >

1476 > // Use a context that we know is cancelled so that this doesn't block.

1477 > engine, _ := s.engineFuture.Get(s.lifecycleCtx)

1478 >

1479 > // Stop the engine if it was running (outside the lock but before returning).

1480 > if engine != nil {

1481 s.contextTaggedLogger.Info("", tag.LifeCycleStopping, tag.ComponentShardEngine)

1482 engine.Stop()

1485

1486 // Run finalizer to cleanup any of the shard's associated resources that are registered.

1487 > if s.finalizer != nil { context_impl.go

1488 s.finalizer.Run(s.config.ShardFinalizerTimeout())

1489 }

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(

1558 }

1559

1560 > func (s *ContextImpl) transition(request contextRequest) error { context_impl.go

1561 > /* State transitions:

1562 >

1563 > The normal pattern:

1564 > Initialized

1565 > controller calls start()

1566 > Acquiring

1567 > acquireShard gets the shard

1568 > Acquired

1569 >

1570 > If we get a transient error from persistence:

1571 > Acquired

1572 > transient error: handleErrorLocked calls transition(contextRequestLost)

1573 > Acquiring

1574 > acquireShard gets the shard

1575 > Acquired

1576 >

1577 > If we get shard ownership lost:

1578 > Acquired

1579 > ShardOwnershipLostError: handleErrorLocked calls transition(contextRequestStop)

1580 > Stopping

1581 > controller removes from map and calls FinishStop()

1582 > Stopped

1583 >

1584 > Stopping can be triggered internally (if we get a ShardOwnershipLostError, or fail to acquire the rangeid

1585 > lock after several minutes) or externally (from controller, e.g. controller shutting down or admin force-

1586 > unload shard). If it's triggered internally, we transition to Stopping, then make an asynchronous callback

1587 > to controller, which will remove us from the map and call FinishStop(), which will transition to Stopped and

1588 > stop the engine. If it's triggered externally, we'll skip over Stopping and go straight to Stopped.

1589 >

1590 > If we transition externally to Stopped, and the acquireShard goroutine is still running, we can't kill it,

1591 > but we should make sure that it can't do anything: the context it uses for persistence ops will be

1592 > canceled, and if it tries to transition states, it will fail.

1593 >

1594 > Invariants:

1595 > - Once state is Stopping, it can only go to Stopped.

1596 > - Once state is Stopped, it can't go anywhere else.

1597 > - At the start of acquireShard, state must be Acquiring.

1598 > - By the end of acquireShard, state must not be Acquiring: either acquireShard set it to Acquired, or the

1599 > controller set it to Stopped.

1600 > - If state is Acquiring, acquireShard should be running in the background.

1601 > - Only acquireShard can use contextRequestAcquired (i.e. transition from Acquiring to Acquired).

1602 > - Once state has reached Acquired at least once, and not reached Stopped, engineFuture must be set.

1603 > - Only the controller may call start() and FinishStop().

1604 > - The controller must call FinishStop() for every ContextImpl it creates.

1605 >

1606 > */

1607 >

1608 > s.stateLock.Lock()

1609 > defer s.stateLock.Unlock()

1610 >

1611 > setStateAcquiring := func() {

1612 s.state = contextStateAcquiring

1613 s.contextTaggedLogger.Info("", tag.LifeCycleStarted, tag.ComponentShardContext)

1615 }

1616

1617 > setStateStopping := func(request contextRequestStop) { context_impl.go

1618 s.state = contextStateStopping

1619 s.stopReason = request.reason

1627 }

1628

1629 > setStateStopped := func() { context_impl.go

1630 > s.state = contextStateStopped context_impl.go

1631 > s.contextTaggedLogger.Info("", tag.LifeCycleStopped, tag.ComponentShardContext)

1632 > // Do this again in case we skipped the stopping state, which could happen

1633 > // when calling CloseShardByID or the controller is shutting down.

1634 > s.lifecycleCancel()

1635 > }

1636

1637 > switch s.state { context_impl.go

1638 case contextStateInitialized:

1639 switch request := request.(type) {

1681 return nil

1682 }

1683 > case contextStateAcquired: context_impl.go

1684 > switch request := request.(type) {

1685 case contextRequestAcquire:

1686 return nil // nothing to do, already acquired

1691 setStateStopping(request)

1692 return nil

1693 > case contextRequestFinishStop: context_impl.go

1694 > setStateStopped()

1695 > return nil

1696 }

1697 case contextStateStopping:

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 {

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 {

go.temporal.io/server/service/history/ndc/state_rebuilder.go 146 covered LOC · 21 ranges

Open complete file

85 shard historyi.ShardContext,

86 logger log.Logger,

87 > ) *StateRebuilderImpl { state_rebuilder.go

88 >

89 > return &StateRebuilderImpl{

90 > shard: shard,

91 > namespaceRegistry: shard.GetNamespaceRegistry(),

92 > eventsCache: shard.GetEventsCache(),

93 > clusterMetadata: shard.GetClusterMetadata(),

94 > executionMgr: shard.GetExecutionManager(),

95 > taskRefresher: workflow.NewTaskRefresher(shard),

96 > rebuiltHistorySize: 0,

97 > rebuiltExternalPayloadSize: 0,

98 > rebuiltExternalPayloadCount: 0,

99 > logger: logger,

100 > }

101 > }

102

103 func (r *StateRebuilderImpl) Rebuild(

111 targetBranchToken []byte,

112 requestID string,

113 > ) (historyi.MutableState, RebuildStats, error) { state_rebuilder.go

114 > rebuiltMutableState, lastTxnId, err := r.buildMutableStateFromEvent(

115 > ctx,

116 > now,

117 > baseWorkflowIdentifier,

118 > baseBranchToken,

119 > baseLastEventID,

120 > baseLastEventVersion,

121 > targetWorkflowIdentifier,

122 > targetBranchToken,

123 > requestID,

124 > )

125 > if err != nil {

126 return nil, RebuildStats{}, err

127 }

128

129 // close rebuilt mutable state transaction clearing all generated tasks, etc.

130 > _, _, err = rebuiltMutableState.CloseTransactionAsSnapshot(ctx, historyi.TransactionPolicyPassive) state_rebuilder.go

131 > if err != nil {

132 return nil, RebuildStats{}, err

133 }

134

135 > rebuiltMutableState.GetExecutionInfo().LastFirstEventTxnId = lastTxnId state_rebuilder.go

136 >

137 > // refresh tasks to be generated

138 > // TODO: ideally the executionTimeoutTimerTaskStatus field should be carried over

139 > // from the base run. However, RefreshTasks always resets that field and

140 > // force regenerates the execution timeout timer task.

141 > if err := r.taskRefresher.Refresh(ctx, rebuiltMutableState, false); err != nil {

142 return nil, RebuildStats{}, err

143 }

144

145 > return rebuiltMutableState, RebuildStats{ state_rebuilder.go

146 > HistorySize: r.rebuiltHistorySize,

147 > ExternalPayloadSize: r.rebuiltExternalPayloadSize,

148 > ExternalPayloadCount: r.rebuiltExternalPayloadCount,

149 > }, nil

150 }

151

232 targetBranchToken []byte,

233 requestID string,

234 > ) (historyi.MutableState, int64, error) { state_rebuilder.go

235 > namespaceEntry, err := r.namespaceRegistry.GetNamespaceByID(namespace.ID(targetWorkflowIdentifier.NamespaceID))

236 > if err != nil {

237 return nil, 0, err

238 }

239

240 > iter := collection.NewPagingIterator(r.getPaginationFn( state_rebuilder.go

241 > ctx,

242 > common.FirstEventID,

243 > baseLastEventID+1,

244 > baseBranchToken,

245 > namespaceEntry.Name().String(),

246 > ))

247 >

248 > rebuiltMutableState, stateBuilder := r.initializeBuilders(

249 > namespaceEntry,

250 > targetWorkflowIdentifier,

251 > now,

252 > )

253 >

254 > var lastTxnId int64

255 > for iter.HasNext() {

256 > history, err := iter.Next()

257 > switch err.(type) {

258 > case nil:

259 // noop

260 case *serviceerror.DataLoss:

265 }

266

267 > if err := r.applyEvents( state_rebuilder.go

268 > ctx,

269 > targetWorkflowIdentifier,

270 > stateBuilder,

271 > history.History.Events,

272 > requestID,

273 > ); err != nil {

274 return nil, 0, err

275 }

276

277 > lastTxnId = history.TransactionID state_rebuilder.go

278 }

279

280 > if err := rebuiltMutableState.SetCurrentBranchToken(targetBranchToken); err != nil { state_rebuilder.go

281 return nil, 0, err

282 }

283 > currentVersionHistory, err := versionhistory.GetCurrentVersionHistory(rebuiltMutableState.GetExecutionInfo().GetVersionHistories()) state_rebuilder.go

284 > if err != nil {

285 return nil, 0, err

286 }

287 > lastItem, err := versionhistory.GetLastVersionHistoryItem(currentVersionHistory) state_rebuilder.go

288 > if err != nil {

289 return nil, 0, err

290 }

291

292 > if baseLastEventVersion != nil { state_rebuilder.go

293 > if !lastItem.Equal(versionhistory.NewVersionHistoryItem(

294 > baseLastEventID,

295 > *baseLastEventVersion,

296 > )) {

297 return nil, 0, serviceerror.NewInvalidArgumentf(

298 "StateRebuilder unable to Rebuild mutable state to event ID: %v, version: %v, this event must be at the boundary",

302 }

303 }

304 > return rebuiltMutableState, lastTxnId, nil state_rebuilder.go

305 }

306

309 workflowIdentifier definition.WorkflowKey,

310 now time.Time,

311 > ) (historyi.MutableState, workflow.MutableStateRebuilder) { state_rebuilder.go

312 > resetMutableState := workflow.NewMutableState(

313 > r.shard,

314 > r.shard.GetEventsCache(),

315 > r.logger,

316 > namespaceEntry,

317 > workflowIdentifier.GetWorkflowID(),

318 > workflowIdentifier.GetRunID(),

319 > now,

320 > )

321 > stateBuilder := workflow.NewMutableStateRebuilder(

322 > r.shard,

323 > r.logger,

324 > resetMutableState,

325 > )

326 > return resetMutableState, stateBuilder

327 > }

328

329 func (r *StateRebuilderImpl) applyEvents(

333 events []*historypb.HistoryEvent,

334 requestID string,

335 > ) error { state_rebuilder.go

336 >

337 > _, err := stateBuilder.ApplyEvents(

338 > ctx,

339 > namespace.ID(workflowKey.NamespaceID),

340 > requestID,

341 > &commonpb.WorkflowExecution{

342 > WorkflowId: workflowKey.WorkflowID,

343 > RunId: workflowKey.RunID,

344 > },

345 > [][]*historypb.HistoryEvent{events},

346 > nil, // no new run history when rebuilding mutable state

347 > "",

348 > )

349 > if err != nil {

350 r.logger.Error("StateRebuilder unable to Rebuild mutable state.", tag.Error(err))

351 return err

352 }

353 > return nil state_rebuilder.go

354 }

355

360 branchToken []byte,

361 namespaceName string,

362 > ) collection.PaginationFn[HistoryBlobsPaginationItem] { state_rebuilder.go

363 > return func(paginationToken []byte) ([]HistoryBlobsPaginationItem, []byte, error) {

364 > resp, err := r.executionMgr.ReadHistoryBranchByBatch(ctx, &persistence.ReadHistoryBranchRequest{

365 > BranchToken: branchToken,

366 > MinEventID: firstEventID,

367 > MaxEventID: nextEventID,

368 > PageSize: defaultPageSize,

369 > NextPageToken: paginationToken,

370 > ShardID: r.shard.GetShardID(),

371 > })

372 > if err != nil {

373 return nil, nil, err

374 }

375

376 > r.rebuiltHistorySize += int64(resp.Size) state_rebuilder.go

377 > paginateItems := make([]HistoryBlobsPaginationItem, 0, len(resp.History))

378 > for i, history := range resp.History {

379 > nextBatch := HistoryBlobsPaginationItem{

380 > History: history,

381 > TransactionID: resp.TransactionIDs[i],

382 > }

383 > paginateItems = append(paginateItems, nextBatch)

384 >

385 > // Calculate and accumulate external payload size and count for this batch of history events

386 > if r.shard.GetConfig().ExternalPayloadsEnabled(namespaceName) {

387 > externalPayloadSize, externalPayloadCount, err := workflow.CalculateExternalPayloadSize(

388 > history.Events,

389 > metrics.NoopMetricsHandler, // don't record metrics since those are not new uploads

390 > )

391 > if err != nil {

392 return nil, nil, err

393 }

394 > r.rebuiltExternalPayloadSize += externalPayloadSize state_rebuilder.go

395 > r.rebuiltExternalPayloadCount += externalPayloadCount

396 }

397 }

398 > return paginateItems, resp.NextPageToken, nil state_rebuilder.go

399 }

400 }

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/api/persistence/v1/executions.pb.go 128 covered LOC · 25 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 }

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)

809 }

810

811 > func (x *WorkflowExecutionInfo) GetVersionHistories() *v14.VersionHistories { executions.pb.go

812 > if x != nil {

813 > return x.VersionHistories

814 > }

815 return nil

816 }

1040 }

1041

1042 > func (x *WorkflowExecutionInfo) GetVersioningInfo() *v12.WorkflowExecutionVersioningInfo { executions.pb.go

1043 > if x != nil {

1044 > return x.VersioningInfo

1045 > }

1046 return nil

1047 }

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

1223 }

1224

1225 > func (x *TimeSkippingInfo) GetAccumulatedSkippedDuration() *durationpb.Duration { executions.pb.go

1226 > if x != nil {

1227 return x.AccumulatedSkippedDuration

1228 }

1229 > return nil executions.pb.go

1230 }

1231

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)

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

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

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/metrics/tally_metrics_handler.go 115 covered LOC · 32 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

260 // Histogram obtains a histogram for the given name.

261 > func (tmh *tallyMetricsHandler) Histogram(histogram string, unit MetricUnit) HistogramIface { tally_metrics_handler.go

262 > key := histogramCacheKey{name: histogram, unit: unit}

263 > if v, ok := tmh.histograms.Load(key); ok {

264 return v.(HistogramIface) //nolint:revive // type-safe: only HistogramIface is stored

265 }

266 > h := HistogramFunc(func(i int64, t ...Tag) { tally_metrics_handler.go

267 > tmh.cachedTaggedScope(t).Histogram(histogram, tmh.perUnitBuckets[unit]).RecordValue(float64(i)) tally_metrics_handler.go

268 > })

269 > actual, _ := tmh.histograms.LoadOrStore(key, h) tally_metrics_handler.go

270 > return actual.(HistogramIface) //nolint:revive // type-safe: only HistogramIface is stored

271 }

272

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/service/history/shard/context_testutil.go 99 covered LOC · 7 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

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) {

235 // should call that, but integration tests need to do it also to clean up any

236 // background acquireShard goroutines that may exist.

237 > func (s *ContextTest) StopForTest() { context_testutil.go

238 > s.FinishStop()

239 > }

240

241 func (s *StubContext) GetEngine(_ context.Context) (historyi.Engine, error) {

go.temporal.io/server/service/history/workflow/mutable_state_rebuilder.go 85 covered LOC · 19 ranges

Open complete file

58 logger log.Logger,

59 mutableState historyi.MutableState,

60 > ) *MutableStateRebuilderImpl { mutable_state_rebuilder.go

61 >

62 > return &MutableStateRebuilderImpl{

63 > shard: shard,

64 > clusterMetadata: shard.GetClusterMetadata(),

65 > namespaceRegistry: shard.GetNamespaceRegistry(),

66 > logger: logger,

67 > mutableState: mutableState,

68 > }

69 > }

70

71 func (b *MutableStateRebuilderImpl) ApplyEvents(

77 newRunHistory []*historypb.HistoryEvent,

78 newRunID string,

79 > ) (historyi.MutableState, error) { mutable_state_rebuilder.go

80 > for i := 0; i < len(history)-1; i++ {

81 _, err := b.applyEvents(ctx, namespaceID, requestID, execution, history[i], nil, "")

82 if err != nil {

84 }

85 }

86 > newMutableState, err := b.applyEvents(ctx, namespaceID, requestID, execution, history[len(history)-1], newRunHistory, newRunID) mutable_state_rebuilder.go

87 > if err != nil {

88 return nil, err

89 }

91 // close the transaction.

92 // Previously this comment was here: must generate the activity timer / user timer at the very end

93 > taskGenerator := GetTaskGeneratorProvider().NewTaskGenerator(b.shard, b.mutableState) mutable_state_rebuilder.go

94 > if err := taskGenerator.GenerateActivityTimerTasks(); err != nil {

95 return nil, err

96 }

97 > if err := taskGenerator.GenerateUserTimerTasks(); err != nil { mutable_state_rebuilder.go

98 return nil, err

99 }

100 > b.mutableState.SetHistoryBuilder(historybuilder.NewImmutable(history...)) mutable_state_rebuilder.go

101 > return newMutableState, nil

102 }

103

110 newRunHistory []*historypb.HistoryEvent,

111 newRunID string,

112 > ) (historyi.MutableState, error) { mutable_state_rebuilder.go

113 >

114 > if len(history) == 0 {

115 return nil, serviceerror.NewInternal(ErrMessageHistorySizeZero)

116 }

117 > firstEvent := history[0] mutable_state_rebuilder.go

118 > lastEvent := history[len(history)-1]

119 >

120 > taskGenerator := GetTaskGeneratorProvider().NewTaskGenerator(b.shard, b.mutableState)

121 >

122 > // Need to clear the sticky task queue because workflow turned to passive.

123 > b.mutableState.ClearStickyTaskQueue()

124 > executionInfo := b.mutableState.GetExecutionInfo()

125 > executionInfo.LastFirstEventId = firstEvent.GetEventId()

126 >

127 > // Preserve the WorkflowTaskStamp during rebuild to ensure workflow task validation works correctly.

128 > // The stamp is used to invalidate stale workflow tasks and must be maintained across rebuilds.

129 > // Note: The stamp is already persisted in the execution info and should not be reset here.

130 >

131 > // NOTE: stateRebuilder is also being used in the active side

132 > if err := b.mutableState.UpdateCurrentVersion(lastEvent.GetVersion(), true); err != nil {

133 return nil, err

134 }

135 > versionHistories := executionInfo.GetVersionHistories() mutable_state_rebuilder.go

136 > versionHistory, err := versionhistory.GetCurrentVersionHistory(versionHistories)

137 > if err != nil {

138 return nil, err

139 }

140 > if err := versionhistory.AddOrUpdateVersionHistoryItem(versionHistory, versionhistory.NewVersionHistoryItem( mutable_state_rebuilder.go

141 > lastEvent.GetEventId(),

142 > lastEvent.GetVersion(),

143 > )); err != nil {

144 return nil, err

145 }

146 > executionInfo.LastRunningClock = lastEvent.GetTaskId() mutable_state_rebuilder.go

147 >

148 > // [history] is a single persistence batch, so firstEvent.EventId is the batch ID for every

149 > // event applied below. Event definitions that generate load tokens (e.g. NexusOperationScheduled)

150 > // read this via GenerateEventLoadToken to find the original batch ID.

151 > b.mutableState.SetReplayEventBatchID(firstEvent.GetEventId())

152 >

153 > for _, event := range history {

154 > switch event.GetEventType() {

155 > case enumspb.EVENT_TYPE_WORKFLOW_EXECUTION_STARTED: mutable_state_rebuilder.go

156 > attributes := event.GetWorkflowExecutionStartedEventAttributes()

157 > // TODO (alex): ParentWorkflowNamespaceId is back filled. Backward compatibility: old event doesn't have ParentNamespaceId set.

158 > if attributes.GetParentWorkflowNamespaceId() == "" && attributes.GetParentWorkflowNamespace() != "" {

159 parentNamespaceEntry, err := b.namespaceRegistry.GetNamespace(namespace.Name(attributes.GetParentWorkflowNamespace()))

160 if err != nil {

164 }

165

166 > if err := b.mutableState.ApplyWorkflowExecutionStartedEvent( mutable_state_rebuilder.go

167 > nil, // shard clock is local to cluster

168 > execution,

169 > requestID,

170 > event,

171 > ); err != nil {

172 return nil, err

173 }

174

175 > if err := taskGenerator.GenerateRecordWorkflowStartedTasks( mutable_state_rebuilder.go

176 > event,

177 > ); err != nil {

178 return nil, err

179 }

180

181 > var err error mutable_state_rebuilder.go

182 > executionInfo.WorkflowExecutionTimerTaskStatus, err = taskGenerator.GenerateWorkflowStartTasks(

183 > event,

184 > )

185 > if err != nil {

186 return nil, err

187 }

188

189 > if timestamp.DurationValue(attributes.GetFirstWorkflowTaskBackoff()) > 0 { mutable_state_rebuilder.go

190 if err := taskGenerator.GenerateDelayedWorkflowTasks(

191 event,

195 }

196

197 > if err := b.mutableState.SetHistoryTree( mutable_state_rebuilder.go

198 > executionInfo.WorkflowExecutionTimeout,

199 > executionInfo.WorkflowRunTimeout,

200 > execution.GetRunId(),

201 > ); err != nil {

202 return nil, err

203 }

514 // No mutable state action is needed

515

516 > case enumspb.EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED: mutable_state_rebuilder.go

517 > if err := b.mutableState.ApplyWorkflowExecutionSignaled(

518 > event,

519 > ); err != nil {

520 return nil, err

521 }

691

692 // The length of newRunHistory can be zero in resend case

693 > if len(newRunHistory) == 0 { mutable_state_rebuilder.go

694 > return nil, nil

695 > }

696

697 if b.mutableState.GetExecutionState().Status == enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING {

go.temporal.io/server/chasm/search_attribute.go 84 covered LOC · 13 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 {

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.

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.

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/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 zap_logger.go

126 > }

127 > return msg zap_logger.go

128 }

129

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/workflow/task_generator.go 68 covered LOC · 15 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(

128 startEvent *historypb.HistoryEvent,

129 > ) (int32, error) { task_generator.go

130 >

131 > executionInfo := r.mutableState.GetExecutionInfo()

132 > executionTimeoutTimerTaskStatus := executionInfo.WorkflowExecutionTimerTaskStatus

133 > if !r.mutableState.IsWorkflowExecutionRunning() {

134 return executionTimeoutTimerTaskStatus, nil

135 }

136

137 > workflowExecutionTimeoutTimerEnabled := r.config.EnableWorkflowExecutionTimeoutTimer() task_generator.go

138 > if !workflowExecutionTimeoutTimerEnabled {

139 // when the feature is disabled, reset this field so that it won't be carried over to the next run

140 // and new runs can always have the run timeout timer always generated.

155 // into the situation where execution timeout is set but no timeout timer task is generated.

156

157 > isFirstRun := executionInfo.FirstExecutionRunId == r.mutableState.GetExecutionState().RunId task_generator.go

158 > workflowExecutionExpirationTime := timestamp.TimeValue(

159 > executionInfo.WorkflowExecutionExpirationTime,

160 > )

161 > if workflowExecutionTimeoutTimerEnabled &&

162 > !isFirstRun &&

163 > !workflowExecutionExpirationTime.IsZero() &&

164 > executionInfo.WorkflowExecutionTimerTaskStatus == TimerTaskStatusNone {

165 r.mutableState.AddTasks(&tasks.WorkflowExecutionTimeoutTask{

166 // TaskID is set by shard

173 }

174

175 > workflowRunExpirationTime := timestamp.TimeValue( task_generator.go

176 > executionInfo.WorkflowRunExpirationTime,

177 > )

178 > if workflowRunExpirationTime.IsZero() {

179 return executionTimeoutTimerTaskStatus, nil

180 }

181 > if executionTimeoutTimerTaskStatus == TimerTaskStatusNone || task_generator.go

182 > workflowRunExpirationTime.Before(workflowExecutionExpirationTime) {

183 > r.mutableState.AddTasks(&tasks.WorkflowRunTimeoutTask{ task_generator.go

184 > // TaskID is set by shard

185 > WorkflowKey: r.mutableState.GetWorkflowKey(),

186 > VisibilityTimestamp: workflowRunExpirationTime,

187 > Version: startEvent.GetVersion(),

188 > })

189 > }

190

191 > return executionTimeoutTimerTaskStatus, nil task_generator.go

192 }

193

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

408 func (r *TaskGeneratorImpl) GenerateRecordWorkflowStartedTasks(

409 startEvent *historypb.HistoryEvent,

410 > ) error { task_generator.go

411 >

412 > startVersion := startEvent.GetVersion()

413 >

414 > r.mutableState.AddTasks(&tasks.StartExecutionVisibilityTask{

415 > // TaskID, VisibilityTimestamp is set by shard

416 > WorkflowKey: r.mutableState.GetWorkflowKey(),

417 > Version: startVersion,

418 > })

419 > return nil

420 > }

421

422 func (r *TaskGeneratorImpl) GenerateScheduleWorkflowTaskTasks(

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/history/v1/message.pb.go 63 covered LOC · 17 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)) message.pb.go

98 > if ms.LoadMessageInfo() == nil {

99 > ms.StoreMessageInfo(mi)

100 > }

101 > return ms

102 }

103 > return mi.MessageOf(x) message.pb.go

104 }

105

109 }

110

111 > func (x *VersionHistoryItem) GetEventId() int64 { message.pb.go

112 > if x != nil {

113 > return x.EventId message.pb.go

114 > }

115 return 0

116 }

117

118 > func (x *VersionHistoryItem) GetVersion() int64 { message.pb.go

119 > if x != nil {

120 > return x.Version message.pb.go

121 > }

122 return 0

123 }

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)) message.pb.go

151 > if ms.LoadMessageInfo() == nil {

152 > ms.StoreMessageInfo(mi)

153 > }

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)) message.pb.go

204 > if ms.LoadMessageInfo() == nil {

205 > ms.StoreMessageInfo(mi)

206 > }

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/service/history/historybuilder/event_store.go 60 covered LOC · 14 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) {

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 event_store.go

262 > }

263

264 taskIDCount := 0

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/historybuilder/history_builder.go 57 covered LOC · 3 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) {

99 }

100

101 > func NewImmutable(histories ...[]*historypb.HistoryEvent) *HistoryBuilder { history_builder.go

102 > lastHistory := histories[len(histories)-1]

103 > lastEvent := lastHistory[len(lastHistory)-1]

104 > return &HistoryBuilder{

105 > EventStore: EventStore{

106 > state: HistoryBuilderStateImmutable,

107 > timeSource: nil,

108 > taskIDGenerator: nil,

109 >

110 > version: lastEvent.GetVersion(),

111 > nextEventID: lastEvent.GetEventId() + 1,

112 >

113 > workflowFinished: false,

114 >

115 > dbBufferBatch: nil,

116 > dbClearBuffer: false,

117 > memEventsBatches: histories,

118 > memLatestBatch: nil,

119 > memBufferBatch: nil,

120 > scheduledIDToStartedID: nil,

121 > requestIDToEventID: nil,

122 >

123 > metricsHandler: nil,

124 > },

125 > EventFactory: EventFactory{},

126 > }

127 > }

128

129 func NewImmutableForUpdateNextEventID(lastVersionHistoryItem *historyspb.VersionHistoryItem) *HistoryBuilder {

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/persistence/v1/hsm.pb.go 56 covered LOC · 13 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

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/common/persistence/data_interfaces_mock.go 54 covered LOC · 11 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.

373

374 // GetHistoryBranchUtil mocks base method.

375 > func (m *MockExecutionManager) GetHistoryBranchUtil() HistoryBranchUtil { data_interfaces_mock.go

376 > m.ctrl.T.Helper()

377 > ret := m.ctrl.Call(m, "GetHistoryBranchUtil")

378 > ret0, _ := ret[0].(HistoryBranchUtil)

379 > return ret0

380 > }

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.

533

534 // ReadHistoryBranchByBatch mocks base method.

535 > func (m *MockExecutionManager) ReadHistoryBranchByBatch(ctx context.Context, request *ReadHistoryBranchRequest) (*ReadHistoryBranchByBatchResponse, error) { data_interfaces_mock.go

536 > m.ctrl.T.Helper()

537 > ret := m.ctrl.Call(m, "ReadHistoryBranchByBatch", ctx, request)

538 > ret0, _ := ret[0].(*ReadHistoryBranchByBatchResponse)

539 > ret1, _ := ret[1].(error)

540 > return ret0, ret1

541 > }

542

543 // ReadHistoryBranchByBatch indicates an expected call of ReadHistoryBranchByBatch.

544 > func (mr *MockExecutionManagerMockRecorder) ReadHistoryBranchByBatch(ctx, request any) *gomock.Call { data_interfaces_mock.go

545 > mr.mock.ctrl.T.Helper()

546 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHistoryBranchByBatch", reflect.TypeOf((*MockExecutionManager)(nil).ReadHistoryBranchByBatch), ctx, request)

547 > }

548

549 // ReadHistoryBranchReverse 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 48 covered LOC · 15 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

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 }

285 // Walk applies the given function to all nodes rooted at the current node.

286 // Returns after successfully applying the function to all nodes or first error.

287 > func (n *Node) Walk(fn func(*Node) error) error { tree.go

288 > if n == nil {

289 return nil

290 }

291

292 > if err := fn(n); err != nil { tree.go

293 return err

294 }

295

296 > for childType := range n.persistence.Children { tree.go

297 childNodes := NewCollection[any](n, childType).List()

298 for _, child := range childNodes {

303 }

304

305 > return nil tree.go

306 }

307

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/collection/paging_iterator.go 38 covered LOC · 14 ranges

Open complete file

18 func NewPagingIterator[V any](

19 paginationFn PaginationFn[V],

20 > ) Iterator[V] { paging_iterator.go

21 > iter := &PagingIteratorImpl[V]{

22 > paginationFn: paginationFn,

23 > pageToken: nil,

24 > pageErr: nil,

25 > pageItems: nil,

26 > nextPageItemIndex: 0,

27 > }

28 > iter.getNextPage() // this will initialize the paging iterator

29 > return iter

30 > }

31

32 // NewPagingIteratorWithToken create a new paging iterator with initial token

47

48 // HasNext return whether has next item or err

49 > func (iter *PagingIteratorImpl[V]) HasNext() bool { paging_iterator.go

50 > // pagination encounters error

51 > if iter.pageErr != nil {

52 return true

53 }

54

55 // still have local cached item to return

56 > if iter.nextPageItemIndex < len(iter.pageItems) { paging_iterator.go

57 > return true paging_iterator.go

58 > }

59

60 > if len(iter.pageToken) != 0 { paging_iterator.go

61 > iter.getNextPage() paging_iterator.go

62 > return iter.HasNext()

63 > }

64

65 > return false paging_iterator.go

66 }

67

68 // Next return next item or err

69 > func (iter *PagingIteratorImpl[V]) Next() (V, error) { paging_iterator.go

70 > if !iter.HasNext() {

71 panic("HistoryEventIterator Next() called without checking HasNext()")

72 }

73

74 > if iter.pageErr != nil { paging_iterator.go

75 err := iter.pageErr

76 iter.pageErr = nil

80

81 // we have cached events

82 > if iter.nextPageItemIndex < len(iter.pageItems) { paging_iterator.go

83 > index := iter.nextPageItemIndex

84 > iter.nextPageItemIndex++

85 > return iter.pageItems[index], nil

86 > }

87

88 panic("HistoryEventIterator Next() should return either a history event or a err")

89 }

90

91 > func (iter *PagingIteratorImpl[V]) getNextPage() { paging_iterator.go

92 > items, token, err := iter.paginationFn(iter.pageToken)

93 > if err == nil {

94 > iter.pageItems = items paging_iterator.go

95 > iter.pageToken = token

96 > iter.pageErr = nil

97 > } else { paging_iterator.go

98 iter.pageItems = nil

99 iter.pageToken = nil

100 iter.pageErr = err

101 }

102 > iter.nextPageItemIndex = 0 paging_iterator.go

103 }

go.temporal.io/server/api/persistence/v1/chasm.pb.go 37 covered LOC · 3 ranges

Open complete file

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

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/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/namespace.go 36 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

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.

284

285 // Retention returns retention duration for this namespace.

286 > func (ns *Namespace) Retention() time.Duration { namespace.go

287 > if ns.config.Retention == nil {

288 > return 0 namespace.go

289 > }

290

291 return ns.config.Retention.AsDuration()

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/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/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/service/history/shard/task_key_generator.go 35 covered LOC · 9 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(

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(

130 func (a *taskKeyGenerator) generateTaskKey(

131 category tasks.Category,

132 > ) (tasks.Key, error) { task_key_generator.go

133 > id, err := a.generateTaskID()

134 > if err != nil {

135 return tasks.Key{}, err

136 }

137

138 > switch category.Type() { task_key_generator.go

139 > case tasks.CategoryTypeImmediate:

140 > return tasks.NewImmediateKey(id), nil

141 case tasks.CategoryTypeScheduled:

142 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(

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/common/backoff/retrypolicy.go 34 covered LOC · 6 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

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/persistence/versionhistory/version_history.go 34 covered LOC · 14 ranges

Open complete file

8

9 // NewVersionHistory create a new instance of VersionHistory.

10 > func NewVersionHistory(branchToken []byte, items []*historyspb.VersionHistoryItem) *historyspb.VersionHistory { version_history.go

11 > return &historyspb.VersionHistory{

12 > BranchToken: branchToken,

13 > Items: items,

14 > }

15 > }

16

17 // CopyVersionHistory copies VersionHistory.

58

59 // SetVersionHistoryBranchToken sets the branch token.

60 > func SetVersionHistoryBranchToken(v *historyspb.VersionHistory, branchToken []byte) { version_history.go

61 > v.BranchToken = make([]byte, len(branchToken))

62 > copy(v.BranchToken, branchToken)

63 > }

64

65 // AddOrUpdateVersionHistoryItem updates the VersionHistory with new VersionHistoryItem.

66 > func AddOrUpdateVersionHistoryItem(v *historyspb.VersionHistory, item *historyspb.VersionHistoryItem) error { version_history.go

67 > if len(v.Items) == 0 {

68 > v.Items = []*historyspb.VersionHistoryItem{CopyVersionHistoryItem(item)} version_history.go

69 > return nil

70 > }

71

72 > lastItem := v.Items[len(v.Items)-1] version_history.go

73 > if item.Version < lastItem.Version {

74 return serviceerror.NewInternalf("cannot update version history with a lower version %v. Last version: %v", item.Version, lastItem.Version)

75 }

76

77 > if item.GetEventId() <= lastItem.GetEventId() { version_history.go

78 return serviceerror.NewInternalf("cannot add version history with a lower event id %v. Last event id: %v", item.GetEventId(), lastItem.GetEventId())

79 }

80

81 > if item.Version > lastItem.Version { version_history.go

82 // Add a new history

83 v.Items = append(v.Items, CopyVersionHistoryItem(item))

84 > } else { version_history.go

85 > // item.Version == lastItem.Version && item.EventID > lastItem.EventID version_history.go

86 > // Update event ID

87 > lastItem.EventId = item.GetEventId()

88 > }

89 > return nil version_history.go

90 }

91

215

216 // GetLastVersionHistoryItem return the last VersionHistoryItem.

217 > func GetLastVersionHistoryItem(v *historyspb.VersionHistory) (*historyspb.VersionHistoryItem, error) { version_history.go

218 > return getLastVersionHistoryItem(v.Items)

219 > }

220

221 > func getLastVersionHistoryItem(v []*historyspb.VersionHistoryItem) (*historyspb.VersionHistoryItem, error) { version_history.go

222 > if len(v) == 0 {

223 return nil, serviceerror.NewInternal("version history is empty.")

224 }

225 > return CopyVersionHistoryItem(v[len(v)-1]), nil version_history.go

226 }

227

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/cache/lru.go 33 covered LOC · 8 ranges

Open complete file

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

go.temporal.io/server/common/log/tag/tags.go 33 covered LOC · 11 ranges

Open complete file

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

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

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

go.temporal.io/server/api/persistence/v1/history_tree.pb.go 32 covered LOC · 5 ranges

Open complete file

122 func (*HistoryBranch) ProtoMessage() {}

123

124 > func (x *HistoryBranch) ProtoReflect() protoreflect.Message { history_tree.pb.go

125 > mi := &file_temporal_server_api_persistence_v1_history_tree_proto_msgTypes[1]

126 > if x != nil {

127 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

128 > if ms.LoadMessageInfo() == nil {

129 > ms.StoreMessageInfo(mi)

130 > }

131 > return ms

132 }

133 return mi.MessageOf(x)

186 func (*HistoryBranchRange) ProtoMessage() {}

187

188 > func (x *HistoryBranchRange) ProtoReflect() protoreflect.Message { history_tree.pb.go

189 > mi := &file_temporal_server_api_persistence_v1_history_tree_proto_msgTypes[2]

190 > if x != nil {

191 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

192 if ms.LoadMessageInfo() == nil {

195 return ms

196 }

197 > return mi.MessageOf(x) history_tree.pb.go

198 }

199

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/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/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/common/searchattribute/sadefs/constants.go 30 covered LOC · 9 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.

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/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/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/service/history/shard/task_key_manager.go 27 covered LOC · 4 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(

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(

63 category tasks.Category,

64 > ) (tasks.Key, error) { task_key_manager.go

65 > return m.generator.generateTaskKey(category)

66 > }

67

68 func (m *taskKeyManager) drainTaskRequests() {

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/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/task.pb.go 26 covered LOC · 4 ranges

Open complete file

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/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/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/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/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/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/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/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/common/cluster/metadata_mock.go 22 covered LOC · 5 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.

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.

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.

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/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/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/shard/task_request_tracker.go 20 covered LOC · 4 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

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/future/future_impl.go 19 covered LOC · 5 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(

43 ctx context.Context,

44 > ) (T, error) { future_impl.go

45 > if f.Ready() {

46 return f.value, f.err

47 }

48

49 > select { future_impl.go

50 case <-f.readyCh:

51 return f.value, f.err

52 > case <-ctx.Done(): future_impl.go

53 > var value T

54 > return value, ctx.Err()

55 }

56 }

104 }

105

106 > func (f *FutureImpl[T]) Ready() bool { future_impl.go

107 > return atomic.LoadInt32(&f.status) == ready

108 > }

go.temporal.io/server/common/namespace/registry_mock.go 19 covered LOC · 4 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.

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/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/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/log/tag/zap_tag.go 18 covered LOC · 4 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 {

go.temporal.io/server/common/namespace/replication_resolver.go 18 covered LOC · 3 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

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/common/persistence/history_branch_util.go 18 covered LOC · 6 ranges

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(

57 _ time.Duration, // executionTimeout

58 _ time.Duration, // retentionDuration

59 > ) ([]byte, error) { history_branch_util.go

60 > var id string

61 > if branchID == nil {

62 > id = primitives.NewUUID().String() history_branch_util.go

63 > } else { history_branch_util.go

64 id = *branchID

65 }

66 > bi := &persistencespb.HistoryBranch{ history_branch_util.go

67 > TreeId: treeID,

68 > BranchId: id,

69 > Ancestors: ancestors,

70 > }

71 > data, err := u.serializer.HistoryBranchToBlob(bi)

72 > if err != nil {

73 return nil, err

74 }

75 > return data.Data, nil history_branch_util.go

76 }

77

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/service/history/workflow/external_payload_size.go 18 covered LOC · 8 ranges

Open complete file

11

12 // CalculateExternalPayloadSize calculates the total size and count of all external payloads in the given history events.

13 > func CalculateExternalPayloadSize(events []*historypb.HistoryEvent, metricsHandler metrics.Handler) (size int64, count int64, err error) { external_payload_size.go

14 > var totalSize int64

15 > var totalCount int64

16 > visitor := func(vpc *proxy.VisitPayloadsContext, payloads []*commonpb.Payload) ([]*commonpb.Payload, error) {

17 > for _, p := range payloads { external_payload_size.go

18 > totalCount += int64(len(p.ExternalPayloads)) external_payload_size.go

19 > for _, extPayload := range p.ExternalPayloads {

20 > totalSize += extPayload.SizeBytes external_payload_size.go

21 > metricsHandler.Histogram(metrics.ExternalPayloadUploadSize.Name(), metrics.Bytes).Record(int64(extPayload.SizeBytes))

22 > }

23 }

24 > return payloads, nil external_payload_size.go

25 }

26

27 > for _, event := range events { external_payload_size.go

28 > err := proxy.VisitPayloads(context.Background(), event, proxy.VisitPayloadsOptions{ external_payload_size.go

29 > Visitor: visitor,

30 > SkipSearchAttributes: true,

31 > })

32 > if err != nil {

33 return 0, 0, err

34 }

35 }

36 > return totalSize, totalCount, nil external_payload_size.go

37 }

go.temporal.io/server/service/history/workflow/task_refresher_mock.go 18 covered LOC · 4 ranges

Open complete file

32

33 // NewMockTaskRefresher creates a new mock instance.

34 > func NewMockTaskRefresher(ctrl *gomock.Controller) *MockTaskRefresher { task_refresher_mock.go

35 > mock := &MockTaskRefresher{ctrl: ctrl}

36 > mock.recorder = &MockTaskRefresherMockRecorder{mock}

37 > return mock

38 > }

39

40 // EXPECT returns an object that allows the caller to indicate expected use.

41 > func (m *MockTaskRefresher) EXPECT() *MockTaskRefresherMockRecorder { task_refresher_mock.go

42 > return m.recorder

43 > }

44

45 // PartialRefresh mocks base method.

58

59 // Refresh mocks base method.

60 > func (m *MockTaskRefresher) Refresh(ctx context.Context, mutableState interfaces.MutableState, shouldSkipGeneratingCloseTransferTask bool) error { task_refresher_mock.go

61 > m.ctrl.T.Helper()

62 > ret := m.ctrl.Call(m, "Refresh", ctx, mutableState, shouldSkipGeneratingCloseTransferTask)

63 > ret0, _ := ret[0].(error)

64 > return ret0

65 > }

66

67 // Refresh indicates an expected call of Refresh.

68 > func (mr *MockTaskRefresherMockRecorder) Refresh(ctx, mutableState, shouldSkipGeneratingCloseTransferTask any) *gomock.Call { task_refresher_mock.go

69 > mr.mock.ctrl.T.Helper()

70 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Refresh", reflect.TypeOf((*MockTaskRefresher)(nil).Refresh), ctx, mutableState, shouldSkipGeneratingCloseTransferTask)

71 > }

go.temporal.io/server/common/persistence/serialization/codec.go 17 covered LOC · 7 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

65 encoding enumspb.EncodingType,

66 options ...EncodeOption,

67 > ) (*commonpb.DataBlob, error) { codec.go

68 > opts := encodeOptions{}

69 > for _, option := range options {

70 option(&opts)

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/primitives/timestamp/duration.go 16 covered LOC · 6 ranges

Open complete file

19 )

20

21 > func DurationValue(d *durationpb.Duration) time.Duration { duration.go

22 > if d == nil {

23 > return 0 duration.go

24 > }

25 return d.AsDuration()

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/testing/protorequire/require.go 16 covered LOC · 8 ranges

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

45 // comparison behavior, e.g. protorequire.IgnoreFields to exclude specific fields.

46 > func ProtoEqual(t require.TestingT, a proto.Message, b proto.Message, opts ...Option) { require.go

47 > if th, ok := t.(helper); ok {

48 > th.Helper() require.go

49 > }

50 > cfg := &config{} require.go

51 > for _, opt := range opts {

52 opt(a, cfg)

53 }

54 > cmpOpts := append([]cmp.Option{protocmp.Transform()}, cfg.cmpOpts...) require.go

55 > if diff := cmp.Diff(a, b, cmpOpts...); diff != "" {

56 require.Fail(t, fmt.Sprintf("Proto mismatch (-want +got):\n%v", diff))

57 }

129 }

130

131 > func (x ProtoAssertions) ProtoEqual(a proto.Message, b proto.Message, opts ...Option) { require.go

132 > if th, ok := x.t.(helper); ok {

133 > th.Helper() require.go

134 > }

135 > ProtoEqual(x.t, a, b, opts...) require.go

136 }

137

go.temporal.io/server/service/history/events/events_cache_mock.go 16 covered LOC · 4 ranges

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.

40 > func (m *MockCache) EXPECT() *MockCacheMockRecorder { events_cache_mock.go

41 > return m.recorder

42 > }

43

44 // DeleteEvent mocks base method.

70

71 // PutEvent mocks base method.

72 > func (m *MockCache) PutEvent(key EventKey, event *history.HistoryEvent) { events_cache_mock.go

73 > m.ctrl.T.Helper()

74 > m.ctrl.Call(m, "PutEvent", key, event)

75 > }

76

77 // PutEvent indicates an expected call of PutEvent.

78 > func (mr *MockCacheMockRecorder) PutEvent(key, event any) *gomock.Call { events_cache_mock.go

79 > mr.mock.ctrl.T.Helper()

80 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEvent", reflect.TypeOf((*MockCache)(nil).PutEvent), key, event)

81 > }

go.temporal.io/server/chasm/registry.go 15 covered LOC · 1 range

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 {

go.temporal.io/server/common/contextutil/metadata.go 15 covered LOC · 6 ranges

Open complete file

99

100 // ContextMetadataGetMarkedActivityIDs returns the marked activity IDs from the context.

101 > func ContextMetadataGetMarkedActivityIDs(ctx context.Context) []string { metadata.go

102 > metadataCtx := getMetadataContext(ctx)

103 > if metadataCtx == nil {

104 > return nil metadata.go

105 > }

106

107 metadataCtx.Lock()

119

120 // getMetadataContext extracts metadata context from golang context.

121 > func getMetadataContext(ctx context.Context) *metadataContext { metadata.go

122 > metadataCtx := ctx.Value(metadataCtxKey)

123 > if metadataCtx == nil {

124 > return nil metadata.go

125 > }

126 mc, ok := metadataCtx.(*metadataContext)

127 if !ok {

147

148 // ContextMetadataSet sets a metadata key-value pair in the context, overwriting any existing value.

149 > func ContextMetadataSet(ctx context.Context, key string, value any) bool { metadata.go

150 > metadataCtx := getMetadataContext(ctx)

151 > if metadataCtx == nil {

152 > return false metadata.go

153 > }

154

155 metadataCtx.Lock()

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/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/common/definition/workflow_key.go 13 covered LOC · 3 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 {

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/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/common/metrics/noop_impl.go 13 covered LOC · 7 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

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.

41 > func (*noopMetricsHandler) Histogram(string, MetricUnit) HistogramIface { noop_impl.go

42 > return NoopHistogramMetricFunc

43 > }

44

45 func (*noopMetricsHandler) Stop(log.Logger) {}

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) {}) noop_impl.go

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/service/history/tasks/key.go 12 covered LOC · 2 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 {

go.temporal.io/server/service/history/shard/handover_tracker.go 11 covered LOC · 2 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

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/service/history/workflow/timeskipping.go 11 covered LOC · 5 ranges

Open complete file

181 }

182

183 > func accumulatedSkippedDuration(source *persistencespb.WorkflowExecutionInfo) time.Duration { timeskipping.go

184 > return source.GetTimeSkippingInfo().GetAccumulatedSkippedDuration().AsDuration()

185 > }

186

187 // =============================================================================

201 }

202

203 > func (ms *MutableStateImpl) accumulatedSkippedDuration() time.Duration { timeskipping.go

204 > return accumulatedSkippedDuration(ms.executionInfo)

205 > }

206

207 // =============================================================================

433 ctx context.Context,

434 transactionPolicy historyi.TransactionPolicy,

435 > ) (needRegenTasks bool) { timeskipping.go

436 > if !ms.IsWorkflow() {

437 return false

438 }

439 > switch transactionPolicy { timeskipping.go

440 case historyi.TransactionPolicyActive:

441 // 1. gate: only a running, time-skipping-enabled, idle workflow may skip time

457 // 4. task regeneration

458 return true

459 > case historyi.TransactionPolicyPassive: timeskipping.go

460 > return false

461 default:

462 ms.logger.Error(fmt.Sprintf("closeTransactionHandleTimeSkipping: unknown transaction policy: %v", transactionPolicy),

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/service/history/workflow/workflow_task_state_machine.go 10 covered LOC · 2 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 {

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/locks/priority_semaphore_impl.go 9 covered LOC · 1 range

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

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/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/tasks/workflow_run_timer.go 9 covered LOC · 3 ranges

Open complete file

40 }

41

42 > func (u *WorkflowRunTimeoutTask) GetVisibilityTime() time.Time { workflow_run_timer.go

43 > return u.VisibilityTimestamp

44 > }

45

46 > func (u *WorkflowRunTimeoutTask) SetVisibilityTime(t time.Time) { workflow_run_timer.go

47 > u.VisibilityTimestamp = t

48 > }

49

50 > func (u *WorkflowRunTimeoutTask) GetCategory() Category { workflow_run_timer.go

51 > return CategoryTimer

52 > }

53

54 func (u *WorkflowRunTimeoutTask) GetType() enumsspb.TaskType {

go.temporal.io/server/service/history/workflow/noop_chasm_tree.go 9 covered LOC · 3 ranges

Open complete file

18 type noopChasmTree struct{}

19

20 > func (*noopChasmTree) CloseTransaction() (chasm.NodesMutation, error) { noop_chasm_tree.go

21 > return chasm.NodesMutation{}, nil

22 > }

23

24 > func (*noopChasmTree) Snapshot(*persistencespb.VersionedTransition) chasm.NodesSnapshot { noop_chasm_tree.go

25 > return chasm.NodesSnapshot{}

26 > }

27

28 func (*noopChasmTree) PartitionedSnapshot(*persistencespb.VersionedTransition) (chasm.NodesSnapshot, *persistencespb.ChasmLocalState) {

62 }

63

64 > func (*noopChasmTree) ArchetypeID() chasm.ArchetypeID { noop_chasm_tree.go

65 > return chasm.WorkflowArchetypeID

66 > }

67

68 func (*noopChasmTree) EachPureTask(

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/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/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/service/history/workflow/util.go 8 covered LOC · 2 ranges

Open complete file

178 //

179 //nolint:revive // cognitive complexity to reduce after old code clean up

180 > func GetEffectiveDeployment(versioningInfo *workflowpb.WorkflowExecutionVersioningInfo) *deploymentpb.Deployment { util.go

181 > if versioningInfo == nil {

182 > return nil

183 > } else if transition := versioningInfo.GetVersionTransition(); transition != nil {

184 if v := transition.GetDeploymentVersion(); v != nil { // v0.32

185 return worker_versioning.DeploymentFromExternalDeploymentVersion(v)

214 // 3. Behavior: this is returned when there is no override (most common case). Behavior is

215 // set based on the worker-sent deployment in the latest WFT completion.

216 > func GetEffectiveVersioningBehavior(versioningInfo *workflowpb.WorkflowExecutionVersioningInfo) enumspb.VersioningBehavior { util.go

217 > if versioningInfo == nil {

218 > return enumspb.VERSIONING_BEHAVIOR_UNSPECIFIED

219 > } else if t := versioningInfo.GetVersionTransition(); t != nil {

220 return enumspb.VERSIONING_BEHAVIOR_AUTO_UPGRADE

221 } else if override := versioningInfo.GetVersioningOverride(); override != nil {

go.temporal.io/server/api/history/v1/message.go-helpers.pb.go 7 covered LOC · 3 ranges

Open complete file

62 // For more information see the documentation for

63 // https://pkg.go.dev/google.golang.org/protobuf/proto#Equal

64 > func (this *VersionHistoryItem) Equal(that interface{}) bool { message.go-helpers.pb.go

65 > if that == nil {

66 return this == nil

67 }

68

69 > var that1 *VersionHistoryItem message.go-helpers.pb.go

70 > switch t := that.(type) {

71 > case *VersionHistoryItem:

72 > that1 = t

73 case VersionHistoryItem:

74 that1 = &t

77 }

78

79 > return proto.Equal(this, that1) message.go-helpers.pb.go

80 }

81

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/metrics/tags.go 6 covered LOC · 2 ranges

Open complete file

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 {

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/serialization/serializer.go 6 covered LOC · 2 ranges

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 {

423 }

424

425 > func (t *serializerImpl) HistoryBranchToBlob(info *persistencespb.HistoryBranch) (*commonpb.DataBlob, error) { serializer.go

426 > return encodeBlob(info, t.encodingType)

427 > }

428

429 // NOTE: HistoryBranch does not have an encoding type; so we use the serializer's encoding type.

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/persistence/versionhistory/version_history_item.go 6 covered LOC · 3 ranges

Open complete file

8

9 // NewVersionHistoryItem create a new instance of VersionHistoryItem.

10 > func NewVersionHistoryItem(eventID int64, version int64) *historyspb.VersionHistoryItem { version_history_item.go

11 > if eventID < 0 || version < 0 {

12 panic(fmt.Sprintf("invalid version history item event ID: %v, version: %v", eventID, version))

13 }

14

15 > return &historyspb.VersionHistoryItem{EventId: eventID, Version: version} version_history_item.go

16 }

17

18 // CopyVersionHistoryItem create a new instance of VersionHistoryItem.

19 > func CopyVersionHistoryItem(item *historyspb.VersionHistoryItem) *historyspb.VersionHistoryItem { version_history_item.go

20 > return NewVersionHistoryItem(item.EventId, item.Version)

21 > }

22

23 // IsEqualVersionHistoryItem checks whether version history items are equal

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/service/history/workflow/task_refresher.go 6 covered LOC · 1 range

Open complete file

55 func NewTaskRefresher(

56 shard historyi.ShardContext,

57 > ) *TaskRefresherImpl { task_refresher.go

58 > return &TaskRefresherImpl{

59 > shard: shard,

60 > taskGeneratorProvider: GetTaskGeneratorProvider(),

61 > }

62 > }

63

64 func (r *TaskRefresherImpl) Refresh(

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/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/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/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/payloads/payloads.go 5 covered LOC · 1 range

Open complete file

13 )

14

15 > func EncodeString(str string) *commonpb.Payloads { payloads.go

16 > // Error can be safely ignored here becase string always can be converted.

17 > ps, _ := defaultDataConverter.ToPayloads(str)

18 > return ps

19 > }

20

21 func EncodeInt(i int) *commonpb.Payloads {

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/primitives/timestamp/time.go 5 covered LOC · 3 ranges

Open complete file

11 }

12

13 > func TimeValue(t *timestamppb.Timestamp) time.Time { time.go

14 > if t == nil {

15 > return time.Time{} time.go

16 > }

17 > return t.AsTime() time.go

18 }

19

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/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/metrics/metrics.go 4 covered LOC · 4 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...) } metrics.go

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/common/util.go 4 covered LOC · 1 range

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

go.temporal.io/server/common/util/util.go 4 covered LOC · 1 range

Open complete file

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/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/chasm/library.go 3 covered LOC · 1 range

Open complete file

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/chasm/registrable_component.go 3 covered LOC · 1 range

Open complete file

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/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/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/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/service/history/tasks/start_visibility_task.go 3 covered LOC · 1 range

Open complete file

47 }

48

49 > func (t *StartExecutionVisibilityTask) GetCategory() Category { start_visibility_task.go

50 > return CategoryVisibility

51 > }

52

53 func (t *StartExecutionVisibilityTask) GetType() enumsspb.TaskType {

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() {}