TestSyncHSM_IncomingLastUpdateVersionedTransitionNewer

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

446 dbRecord *persistencespb.WorkflowMutableState,

447 dbRecordVersion int64,

448 > ) (*MutableStateImpl, error) { mutable_state_impl.go

449 > // startTime will be overridden by DB record

450 > startTime := time.Time{}

451 >

452 > mutableState := NewMutableState(

453 > shard,

454 > eventsCache,

455 > logger,

456 > namespaceEntry,

457 > dbRecord.ExecutionInfo.WorkflowId,

458 > dbRecord.ExecutionState.RunId,

459 > startTime,

460 > )

461 >

462 > if dbRecord.ActivityInfos != nil {

463 mutableState.pendingActivityInfoIDs = dbRecord.ActivityInfos

464 mutableState.approximateSize += int64SizeBytes * len(mutableState.pendingActivityInfoIDs)

465 }

466 > for _, activityInfo := range dbRecord.ActivityInfos { mutable_state_impl.go

467 mutableState.pendingActivityIDToEventID[activityInfo.ActivityId] = activityInfo.ScheduledEventId

468 mutableState.approximateSize += activityInfo.Size()

474 }

475

476 > if dbRecord.TimerInfos != nil { mutable_state_impl.go

477 mutableState.pendingTimerInfoIDs = dbRecord.TimerInfos

478 }

479 > for timerID, timerInfo := range dbRecord.TimerInfos { mutable_state_impl.go

480 mutableState.pendingTimerEventIDToID[timerInfo.GetStartedEventId()] = timerInfo.GetTimerId()

481 mutableState.approximateSize += timerInfo.Size()

483 }

484

485 > if dbRecord.ChildExecutionInfos != nil { mutable_state_impl.go

486 mutableState.pendingChildExecutionInfoIDs = dbRecord.ChildExecutionInfos

487 mutableState.approximateSize += int64SizeBytes * len(mutableState.pendingChildExecutionInfoIDs)

488 }

489 > for _, childInfo := range dbRecord.ChildExecutionInfos { mutable_state_impl.go

490 mutableState.approximateSize += childInfo.Size()

491 }

492

493 > if dbRecord.RequestCancelInfos != nil { mutable_state_impl.go

494 mutableState.pendingRequestCancelInfoIDs = dbRecord.RequestCancelInfos

495 mutableState.approximateSize += int64SizeBytes * len(mutableState.pendingRequestCancelInfoIDs)

496 }

497 > for _, cancelInfo := range dbRecord.RequestCancelInfos { mutable_state_impl.go

498 mutableState.approximateSize += cancelInfo.Size()

499 }

500

501 > if dbRecord.SignalInfos != nil { mutable_state_impl.go

502 mutableState.pendingSignalInfoIDs = dbRecord.SignalInfos

503 mutableState.approximateSize += int64SizeBytes * len(mutableState.pendingSignalInfoIDs)

504 }

505 > for _, signalInfo := range dbRecord.SignalInfos { mutable_state_impl.go

506 mutableState.approximateSize += signalInfo.Size()

507 }

508

509 > mutableState.pendingSignalRequestedIDs = convert.StringSliceToSet(dbRecord.SignalRequestedIds) mutable_state_impl.go

510 > for requestID := range mutableState.pendingSignalRequestedIDs {

511 mutableState.approximateSize += len(requestID)

512 }

513

514 > for _, tombstoneBatch := range dbRecord.ExecutionInfo.SubStateMachineTombstoneBatches { mutable_state_impl.go

515 mutableState.totalTombstones += len(tombstoneBatch.StateMachineTombstones)

516 }

519 // conflict path can surface it without loading ExecutionInfo. Backfill in memory for records

520 // written before that change so the next persist writes it through.

521 > if dbRecord.ExecutionState.FirstExecutionRunId == "" && dbRecord.ExecutionInfo.FirstExecutionRunId != "" { mutable_state_impl.go

522 dbRecord.ExecutionState.FirstExecutionRunId = dbRecord.ExecutionInfo.FirstExecutionRunId

523 }

524

525 > mutableState.approximateSize += dbRecord.ExecutionState.Size() - mutableState.executionState.Size() mutable_state_impl.go

526 > mutableState.executionState = dbRecord.ExecutionState

527 > mutableState.approximateSize += dbRecord.ExecutionInfo.Size() - mutableState.executionInfo.Size()

528 > mutableState.executionInfo = dbRecord.ExecutionInfo

529 >

530 > // StartTime was moved from ExecutionInfo to executionState

531 > if mutableState.executionState.StartTime == nil && dbRecord.ExecutionInfo.StartTime != nil {

532 mutableState.executionState.StartTime = dbRecord.ExecutionInfo.StartTime

533 }

534

535 > mutableState.hBuilder = historybuilder.New( mutable_state_impl.go

536 > mutableState.timeSource,

537 > mutableState.shard.GenerateTaskIDs,

538 > common.EmptyVersion,

539 > dbRecord.NextEventId,

540 > dbRecord.BufferedEvents,

541 > mutableState.metricsHandler,

542 > mutableState.config.MaximumEventBatchSizeInBytes,

543 > )

544 > mutableState.currentVersion = common.EmptyVersion

545 > mutableState.bufferEventsInDB = dbRecord.BufferedEvents

546 > mutableState.stateInDB = dbRecord.ExecutionState.State

547 > mutableState.nextEventIDInDB = dbRecord.NextEventId

548 > mutableState.dbRecordVersion = dbRecordVersion

549 > mutableState.checksum = dbRecord.Checksum

550 > mutableState.initVersionedTransitionInDB()

551 >

552 > if len(dbRecord.Checksum.GetValue()) > 0 {

553 switch {

554 case mutableState.shouldInvalidateCheckum():

566 }

567

568 > mutableState.mustInitHSM() mutable_state_impl.go

569 >

570 > // Track chasm node size even if chasm is not enabled,

571 > // because those nodes are still stored in the mutable state,

572 > // and should be taken into account when deciding if execution

573 > // should be terminated based on mutable state size.

574 > for key, node := range dbRecord.ChasmNodes {

575 nodeSize := len(key) + node.Size()

576 mutableState.approximateSize += nodeSize

579

580 // TODO@time-skipping: support time skipping for chasm

581 > if shard.GetConfig().EnableChasm(namespaceEntry.Name().String()) { mutable_state_impl.go

582 var err error

583 mutableState.chasmTree, err = chasm.NewTreeFromDB(

594 }

595 }

596 > if mutableState.executionInfo.GetTimeSkippingInfo() != nil { mutable_state_impl.go

597 mutableState.wrapTimeSourceWithTimeSkipping()

598 }

599 > return mutableState, nil mutable_state_impl.go

600 }

601

655 }

656

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

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

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

660 }

661

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

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

664 > if err != nil {

665 panic(err)

666 }

667 > ms.stateMachineNode = stateMachineNode mutable_state_impl.go

668 }

669

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

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

672 > }

673

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

675 > return ms.stateMachineNode

676 > }

677

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

679 > return ms.chasmTree

680 > }

681

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

991 }

992

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

994 > return definition.NewWorkflowKey(

995 > ms.executionInfo.NamespaceId,

996 > ms.executionInfo.WorkflowId,

997 > ms.executionState.RunId,

998 > )

999 > }

1000

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

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

1003 > if err != nil {

1004 return nil, err

1005 }

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

1007 }

1008

1120 }

1121

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

1123 > return ms.executionInfo

1124 > }

1125

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

1127 > return ms.executionState

1128 > }

1129

1130 func (ms *MutableStateImpl) FlushBufferedEvents() {

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

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 {

1190

1191 // NextTransitionCount implements hsm.NodeBackend.

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

1193 > if !ms.transitionHistoryEnabled {

1194 return 0

1195 }

1196

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

1198 > if currentVersionedTransition == nil {

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

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

1201 > return 1

1202 > }

1203 return currentVersionedTransition.TransitionCount + 1

1204 }

1287 }

1288

1289 > func (ms *MutableStateImpl) GetLastWriteVersion() (int64, error) { mutable_state_impl.go

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

1291 lastVersionedTransition := ms.CurrentVersionedTransition()

1292 return lastVersionedTransition.NamespaceFailoverVersion, nil

1293 }

1294

1295 > return ms.GetLastEventVersion() mutable_state_impl.go

1296 }

1297

1298 > func (ms *MutableStateImpl) GetLastEventVersion() (int64, error) { mutable_state_impl.go

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

1300 > versionHistory, err := versionhistory.GetCurrentVersionHistory(ms.executionInfo.VersionHistories)

1301 > if err != nil {

1302 return 0, err

1303 }

1304 > lastItem, err := versionhistory.GetLastVersionHistoryItem(versionHistory) mutable_state_impl.go

1305 > if err != nil {

1306 return 0, err

1307 }

1308 > return lastItem.GetVersion(), nil mutable_state_impl.go

1309 }

1310

1312 }

1313

1314 > func (ms *MutableStateImpl) IsCurrentWorkflowGuaranteed() bool { mutable_state_impl.go

1315 > // stateInDB is used like a bloom filter:

1316 > //

1317 > // 1. stateInDB being created / running meaning that this workflow must be the current

1318 > // workflow (assuming there is no rebuild of mutable state).

1319 > // 2. stateInDB being completed does not guarantee this workflow being the current workflow

1320 > // 3. stateInDB being zombie guarantees this workflow not being the current workflow

1321 > // 4. stateInDB cannot be void, void is only possible when mutable state is just initialized

1322 >

1323 > switch ms.stateInDB {

1324 case enumsspb.WORKFLOW_EXECUTION_STATE_VOID:

1325 return false

1326 case enumsspb.WORKFLOW_EXECUTION_STATE_CREATED:

1327 return true

1328 > case enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING: mutable_state_impl.go

1329 > return true

1330 case enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED:

1331 return false

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.

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

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

2391 > return ms.workflowTaskManager.GetStartedWorkflowTask()

2392 > }

2393

2394 func (ms *MutableStateImpl) IsTransientWorkflowTask() bool {

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:

2483 return true

2484 > case enumsspb.WORKFLOW_EXECUTION_STATE_RUNNING: mutable_state_impl.go

2485 > return true

2486 case enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED:

2487 return false

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 }

7407 // However, certain in-memory changes (e.g. speculative workflow task) won't be cleared before releasing

7408 // the lock and have to be excluded from the check.

7409 > func (ms *MutableStateImpl) IsDirty() bool { mutable_state_impl.go

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

7411 > len(ms.InsertTasks) > 0 ||

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

7413 > ms.chasmTree.IsDirty()

7414 > }

7415

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 {

7449 func (ms *MutableStateImpl) StartTransaction(

7450 namespaceEntry *namespace.Namespace,

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

7452 > if ms.IsDirty() {

7453 ms.logger.Error("MutableState encountered dirty transaction",

7454 tag.WorkflowNamespaceID(ms.executionInfo.NamespaceId),

7461 }

7462

7463 > ms.transitionHistoryEnabled = ms.config.EnableTransitionHistory(namespaceEntry.Name().String()) mutable_state_impl.go

7464 >

7465 > namespaceEntry, err := ms.startTransactionHandleNamespaceMigration(namespaceEntry)

7466 > if err != nil {

7467 return false, err

7468 }

7469 > ms.namespaceEntry = namespaceEntry mutable_state_impl.go

7470 > if err := ms.UpdateCurrentVersion(namespaceEntry.FailoverVersion(ms.executionInfo.WorkflowId), false); err != nil {

7471 return false, err

7472 }

7473

7474 > flushBeforeReady, err := ms.startTransactionHandleWorkflowTaskFailover() mutable_state_impl.go

7475 > if err != nil {

7476 return false, err

7477 }

7478

7479 > return flushBeforeReady, nil mutable_state_impl.go

7480 }

7481

7483 ctx context.Context,

7484 transactionPolicy historyi.TransactionPolicy,

7485 > ) (*persistence.WorkflowMutation, []*persistence.WorkflowEvents, error) { mutable_state_impl.go

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

7487 > if err != nil {

7488 return nil, nil, err

7489 }

7490

7491 > if result.skipPersistence { mutable_state_impl.go

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

7493 return nil, nil, err

7496 }

7497

7498 > workflowMutation := &persistence.WorkflowMutation{ mutable_state_impl.go

7499 > ExecutionInfo: ms.executionInfo,

7500 > ExecutionState: ms.executionState,

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

7502 >

7503 > UpsertActivityInfos: ms.updateActivityInfos,

7504 > DeleteActivityInfos: ms.deleteActivityInfos,

7505 > UpsertTimerInfos: ms.updateTimerInfos,

7506 > DeleteTimerInfos: ms.deleteTimerInfos,

7507 > UpsertChildExecutionInfos: ms.updateChildExecutionInfos,

7508 > DeleteChildExecutionInfos: ms.deleteChildExecutionInfos,

7509 > UpsertRequestCancelInfos: ms.updateRequestCancelInfos,

7510 > DeleteRequestCancelInfos: ms.deleteRequestCancelInfos,

7511 > UpsertSignalInfos: ms.updateSignalInfos,

7512 > DeleteSignalInfos: ms.deleteSignalInfos,

7513 > UpsertSignalRequestedIDs: ms.updateSignalRequestedIDs,

7514 > DeleteSignalRequestedIDs: ms.deleteSignalRequestedIDs,

7515 > UpsertChasmNodes: result.chasmNodesMutation.UpdatedNodes,

7516 > DeleteChasmNodes: result.chasmNodesMutation.DeletedNodes,

7517 > NewBufferedEvents: result.bufferEvents,

7518 > ClearBufferedEvents: result.clearBuffer,

7519 >

7520 > Tasks: ms.InsertTasks,

7521 > BestEffortDeleteTasks: ms.BestEffortDeleteTasks,

7522 >

7523 > Condition: ms.nextEventIDInDB,

7524 > DBRecordVersion: ms.dbRecordVersion,

7525 > Checksum: result.checksum,

7526 > }

7527 >

7528 > ms.checksum = result.checksum

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

7530 return nil, nil, err

7531 }

7532 > return workflowMutation, result.workflowEventsSeq, nil mutable_state_impl.go

7533 }

7534

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

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)

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

8247 if err != nil {

8251 }

8252 }

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

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

8255 >

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

8257 > isWorkflow := archetypeID == chasm.WorkflowArchetypeID

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

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

8260 }

8261

8262 > if ms.transitionHistoryEnabled { mutable_state_impl.go

8263 > switch transactionPolicy { mutable_state_impl.go

8264 case historyi.TransactionPolicyActive:

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{

8439 NamespaceID: ms.executionInfo.NamespaceId,

8459 }

8460

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

8462 > transactionPolicy,

8463 > workflowEventsSeq,

8464 > ); err != nil {

8465 return nil, nil, nil, false, err

8466 }

8467

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

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

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

8477 }

8478

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

8480 }

8481

8499 func (ms *MutableStateImpl) syncActivityToReplicationTask(

8500 transactionPolicy historyi.TransactionPolicy,

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

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

8503 > switch transactionPolicy {

8504 case historyi.TransactionPolicyActive:

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

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

8685 func (ms *MutableStateImpl) startTransactionHandleNamespaceMigration(

8686 namespaceEntry *namespace.Namespace,

8687 > ) (*namespace.Namespace, error) { mutable_state_impl.go

8688 > // NOTE:

8689 > // the main idea here is to guarantee that buffered events & namespace migration works

8690 > // e.g. handle buffered events during version 0 => version > 0 by postponing namespace migration

8691 > // * flush buffered events as if namespace is still local

8692 > // * use updated namespace for actual call

8693 >

8694 > lastWriteVersion, err := ms.GetLastWriteVersion()

8695 > if err != nil {

8696 return nil, err

8697 }

8698

8699 // local namespace -> global namespace && with started workflow task

8700 > if lastWriteVersion == common.EmptyVersion && namespaceEntry.FailoverVersion(ms.executionInfo.WorkflowId) > common.EmptyVersion && ms.HasStartedWorkflowTask() { mutable_state_impl.go

8701 localNamespaceMutation := namespace.WithPretendLocalNamespace(

8702 ms.clusterMetadata.GetCurrentClusterName(),

8704 return namespaceEntry.Clone(localNamespaceMutation), nil

8705 }

8706 > return namespaceEntry, nil mutable_state_impl.go

8707 }

8708

8709 > func (ms *MutableStateImpl) startTransactionHandleWorkflowTaskFailover() (bool, error) { mutable_state_impl.go

8710 > if !ms.IsWorkflowExecutionRunning() {

8711 return false, nil

8712 }

8717

8718 // Handling mutable state turn from standby to active, while having a workflow task on the fly

8719 > workflowTask := ms.GetStartedWorkflowTask() mutable_state_impl.go

8720 > currentVersion := ms.GetCurrentVersion()

8721 > if workflowTask == nil || workflowTask.Version >= currentVersion {

8722 > // no pending workflow tasks, no buffered events

8723 > // or workflow task has higher / equal version

8724 > return false, nil

8725 > }

8726

8727 lastEventVersion, err := ms.GetLastEventVersion()

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

9073 }

9074

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

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

9077 > }

9078

9079 func (ms *MutableStateImpl) ApplyMutation(

9586 }

9587

9588 > func (ms *MutableStateImpl) initVersionedTransitionInDB() { mutable_state_impl.go

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

9590 ms.versionedTransitionInDB = ms.CurrentVersionedTransition()

9591 }

9843 }

9844

9845 > func (ms *MutableStateImpl) GetReapplyCandidateEvents() []*historypb.HistoryEvent { mutable_state_impl.go

9846 > return ms.reapplyEventsCandidate

9847 > }

9848

9849 func (ms *MutableStateImpl) IsSubStateMachineDeleted() bool {

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 266 covered LOC · 72 ranges

Open complete file

210 }

211

212 > func (s *ContextImpl) GetShardID() int32 { context_impl.go

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

214 > return s.shardID

215 > }

216

217 func (s *ContextImpl) GetRangeID() int64 {

222 }

223

224 > func (s *ContextImpl) GetOwner() string { context_impl.go

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

226 > return s.owner

227 > }

228

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

265 func (s *ContextImpl) GetEngine(

266 ctx context.Context,

267 > ) (historyi.Engine, error) { context_impl.go

268 > return s.engineFuture.Get(ctx)

269 > }

270

271 func (s *ContextImpl) AssertOwnership(

313 }

314

315 > func (s *ContextImpl) CurrentVectorClock() *clockspb.VectorClock { context_impl.go

316 > s.rLock()

317 > defer s.rUnlock()

318 >

319 > nextTaskKey := s.taskKeyManager.peekTaskKey(tasks.CategoryTransfer)

320 > return vclock.NewVectorClock(s.clusterMetadata.GetClusterID(), s.shardID, nextTaskKey.TaskID)

321 > }

322

323 func (s *ContextImpl) GenerateTaskID() (int64, error) {

328 }

329

330 > func (s *ContextImpl) GetFinalizer() *finalizer.Finalizer { context_impl.go

331 > return s.finalizer

332 > }

333

334 > func (s *ContextImpl) GenerateTaskIDs(number int) ([]int64, error) { context_impl.go

335 > s.wLock()

336 > defer s.wUnlock()

337 >

338 > result := []int64{}

339 > for range number {

340 id, err := s.generateTaskIDLocked()

341 if err != nil {

344 result = append(result, id)

345 }

346 > return result, nil context_impl.go

347 }

348

596 ctx context.Context,

597 request *persistence.UpdateWorkflowExecutionRequest,

598 > ) (*persistence.UpdateWorkflowExecutionResponse, error) { context_impl.go

599 > // do not try to get namespace cache within shard lock

600 > namespaceID := namespace.ID(request.UpdateWorkflowMutation.ExecutionInfo.NamespaceId)

601 > namespaceEntry, err := s.GetNamespaceRegistry().GetNamespaceByID(namespaceID)

602 > if err != nil {

603 return nil, err

604 }

605

606 > if err := s.ioSemaphoreAcquire(ctx); err != nil { context_impl.go

607 return nil, err

608 }

609 > defer s.ioSemaphoreRelease() context_impl.go

610 >

611 > s.wLock()

612 >

613 > // timeout check should be done within the shard lock, in case of shard lock contention

614 > ctx, cancel, err := s.newDetachedContext(ctx)

615 > if err != nil {

616 s.wUnlock()

617 return nil, err

618 }

619 > defer cancel() context_impl.go

620 >

621 > if err := s.errorByState(); err != nil {

622 s.wUnlock()

623 return nil, err

624 }

625

626 > if err := s.errorByNamespaceStateLocked(namespaceEntry.Name(), request.UpdateWorkflowMutation.ExecutionInfo.WorkflowId); err != nil { context_impl.go

627 s.wUnlock()

628 return nil, err

629 }

630

631 > taskMaps := make([]map[tasks.Category][]tasks.Task, 0, 2) context_impl.go

632 > taskMaps = append(taskMaps, request.UpdateWorkflowMutation.Tasks)

633 > if request.NewWorkflowSnapshot != nil {

634 taskMaps = append(taskMaps, request.NewWorkflowSnapshot.Tasks)

635 }

636 > requestCompletionFn, err := s.taskKeyManager.setAndTrackTaskKeys(taskMaps...) context_impl.go

637 > if err != nil {

638 s.wUnlock()

639 return nil, err

640 }

641 > s.updateCloseTaskIDs(request.UpdateWorkflowMutation.ExecutionInfo, request.UpdateWorkflowMutation.Tasks) context_impl.go

642 > if request.NewWorkflowSnapshot != nil {

643 s.updateCloseTaskIDs(request.NewWorkflowSnapshot.ExecutionInfo, request.NewWorkflowSnapshot.Tasks)

644 }

645

646 > request.RangeID = s.getRangeIDLocked() context_impl.go

647 > s.wUnlock()

648 >

649 > resp, err := s.executionManager.UpdateWorkflowExecution(ctx, request)

650 > requestCompletionFn(err)

651 > if err = s.handleWriteError(request.RangeID, err); err != nil {

652 return nil, err

653 }

654 > return resp, nil context_impl.go

655 }

656

657 > func (s *ContextImpl) updateCloseTaskIDs(executionInfo *persistencespb.WorkflowExecutionInfo, tasksByCategory map[tasks.Category][]tasks.Task) { context_impl.go

658 > for _, t := range tasksByCategory[tasks.CategoryTransfer] {

659 if t.GetType() == enumsspb.TASK_TYPE_TRANSFER_CLOSE_EXECUTION {

660 executionInfo.CloseTransferTaskId = t.GetTaskID()

662 }

663 }

664 > for _, t := range tasksByCategory[tasks.CategoryVisibility] { context_impl.go

665 if t.GetType() == enumsspb.TASK_TYPE_VISIBILITY_CLOSE_EXECUTION ||

666 t.GetType() == enumsspb.TASK_TYPE_CHASM {

807 ctx context.Context,

808 request *persistence.GetWorkflowExecutionRequest,

809 > ) (*persistence.GetWorkflowExecutionResponse, error) { context_impl.go

810 > if err := s.errorByState(); err != nil {

811 return nil, err

812 }

813

814 > resp, err := s.executionManager.GetWorkflowExecution(ctx, request) context_impl.go

815 > if err = s.handleReadError(err); err != nil {

816 // also return resp, for RebuildMutableState API

817 return resp, err

818 }

819 > return resp, nil context_impl.go

820 }

821

1100 }

1101

1102 > func (s *ContextImpl) GetConfig() *configs.Config { context_impl.go

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

1104 > return s.config

1105 > }

1106

1107 > func (s *ContextImpl) GetEventsCache() events.Cache { context_impl.go

1108 > // constant from initialization (except for tests), no need for locks

1109 > return s.eventsCache

1110 > }

1111

1112 > func (s *ContextImpl) GetLogger() log.Logger { context_impl.go

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

1114 > return s.contextTaggedLogger

1115 > }

1116

1117 > func (s *ContextImpl) GetThrottledLogger() log.Logger { context_impl.go

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

1119 > return s.throttledLogger

1120 > }

1121

1122 > func (s *ContextImpl) getRangeIDLocked() int64 { context_impl.go

1123 > return s.shardInfo.GetRangeId()

1124 > }

1125

1126 > func (s *ContextImpl) errorByState() error { context_impl.go

1127 > s.stateLock.Lock()

1128 > defer s.stateLock.Unlock()

1129 >

1130 > switch s.state {

1131 case contextStateInitialized, contextStateAcquiring:

1132 return ErrShardStatusUnknown

1133 > case contextStateAcquired: context_impl.go

1134 > return nil

1135 case contextStateStopping, contextStateStopped:

1136 return s.newShardClosedErrorWithShardID()

1143 namespaceName namespace.Name,

1144 workflowID string,

1145 > ) error { context_impl.go

1146 > if s.handoverTracker.IsInHandover(namespaceName, workflowID) {

1147 return consts.ErrNamespaceHandover

1148 }

1149 > return nil context_impl.go

1150 }

1151

1365 }

1366

1367 > func (s *ContextImpl) handleReadError(err error) error { context_impl.go

1368 > switch err.(type) {

1369 > case nil: context_impl.go

1370 > return nil

1371

1372 case *persistence.ShardOwnershipLostError:

1384 requestRangeID int64,

1385 err error,

1386 > ) error { context_impl.go

1387 > s.wLock()

1388 > defer s.wUnlock()

1389 >

1390 > return s.handleWriteErrorLocked(requestRangeID, err)

1391 > }

1392

1393 func (s *ContextImpl) handleWriteErrorLocked(

1394 requestRangeID int64,

1395 err error,

1396 > ) error { context_impl.go

1397 >

1398 > if requestRangeID != s.getRangeIDLocked() {

1399 return err

1400 }

1401

1402 > if valid := s.IsValid(); !valid { context_impl.go

1403 return err

1404 }

1405 > switch err.(type) { context_impl.go

1406 > case nil: context_impl.go

1407 > // Persistence success: update max read level

1408 > return nil

1409

1410 case *persistence.AppendHistoryTimeoutError:

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

1482 > engine.Stop()

1483 > s.contextTaggedLogger.Info("", tag.LifeCycleStopped, tag.ComponentShardEngine)

1484 > }

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 }

1490 }

1491

1492 > func (s *ContextImpl) IsValid() bool { context_impl.go

1493 > s.stateLock.Lock()

1494 > defer s.stateLock.Unlock()

1495 > return s.state < contextStateStopping

1496 > }

1497

1498 func (s *ContextImpl) GetLifecycleContext() context.Context {

1506 }

1507

1508 > func (s *ContextImpl) wLock() { context_impl.go

1509 > handler := s.metricsHandler.WithTags(metrics.OperationTag(metrics.ShardInfoScope))

1510 > metrics.LockRequests.With(handler).Record(1)

1511 > startTime := time.Now().UTC()

1512 > defer func() { metrics.LockLatency.With(handler).Record(time.Since(startTime)) }()

1513

1514 > s.rwLock.Lock() context_impl.go

1515 }

1516

1517 > func (s *ContextImpl) rLock() { context_impl.go

1518 > handler := s.metricsHandler.WithTags(metrics.OperationTag(metrics.ShardInfoScope))

1519 > metrics.LockRequests.With(handler).Record(1)

1520 > startTime := time.Now().UTC()

1521 > defer func() { metrics.LockLatency.With(handler).Record(time.Since(startTime)) }()

1522

1523 > s.rwLock.RLock() context_impl.go

1524 }

1525

1526 > func (s *ContextImpl) wUnlock() { context_impl.go

1527 > s.rwLock.Unlock()

1528 > }

1529

1530 > func (s *ContextImpl) rUnlock() { context_impl.go

1531 > s.rwLock.RUnlock()

1532 > }

1533

1534 func (s *ContextImpl) ioSemaphoreAcquire(

1535 ctx context.Context,

1536 > ) (retErr error) { context_impl.go

1537 > priority := locks.PriorityHigh

1538 > callerInfo := headers.GetCallerInfo(ctx)

1539 > if callerInfo.CallerType == headers.CallerTypePreemptable {

1540 priority = locks.PriorityLow

1541 }

1542

1543 > handler := s.metricsHandler.WithTags(metrics.OperationTag(metrics.ShardInfoScope), metrics.PriorityTag(priority)) context_impl.go

1544 > metrics.SemaphoreRequests.With(handler).Record(1)

1545 > startTime := time.Now().UTC()

1546 > defer func() {

1547 > metrics.SemaphoreLatency.With(handler).Record(time.Since(startTime))

1548 > if retErr != nil {

1549 metrics.SemaphoreFailures.With(handler).Record(1)

1550 }

1551 }()

1552

1553 > return s.ioSemaphore.Acquire(ctx, priority, 1) context_impl.go

1554 }

1555

1556 > func (s *ContextImpl) ioSemaphoreRelease() { context_impl.go

1557 > s.ioSemaphore.Release(1)

1558 > }

1559

1560 > func (s *ContextImpl) transition(request contextRequest) error { 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 { context_impl.go

2247 > return s.chasmRegistry

2248 > }

2249

2250 func (s *ContextImpl) ChasmWorkflowRegistry() *chasmworkflow.Registry {

2252 }

2253

2254 > func (s *ContextImpl) EndpointRegistry() chasm.EndpointRegistry { context_impl.go

2255 > return s.endpointRegistry

2256 > }

2257

2258 func (s *ContextImpl) BusinessIDReuseRateLimiter(namespaceID namespace.ID, businessID string, archetypeID chasm.ArchetypeID) quotas.RateLimiter {

2303 func (s *ContextImpl) newDetachedContext(

2304 ctx context.Context,

2305 > ) (context.Context, context.CancelFunc, error) { context_impl.go

2306 > if err := ctx.Err(); err != nil {

2307 return nil, nil, err

2308 }

2309

2310 > detachedContext := rpc.CopyContextValues(s.lifecycleCtx, ctx) context_impl.go

2311 >

2312 > var cancel context.CancelFunc

2313 > deadline, ok := ctx.Deadline()

2314 > if ok {

2315 timeout := max(deadline.Sub(s.GetTimeSource().Now()), minContextTimeout)

2316 detachedContext, cancel = context.WithTimeout(detachedContext, timeout)

2317 > } else { context_impl.go

2318 > cancel = func() {} context_impl.go

2319 }

2320

2321 > return detachedContext, cancel, nil context_impl.go

2322 }

2323

go.temporal.io/server/service/history/hsm/tree.go 223 covered LOC · 65 ranges

Open complete file

120 }

121

122 > func (t TransitionOperation) Path() []Key { return t.path } tree.go

123

124 func (TransitionOperation) mustImplementOperation() {}

204 children map[string]*persistencespb.StateMachineMap,

205 backend NodeBackend,

206 > ) (*Node, error) { tree.go

207 > def, ok := registry.Machine(t)

208 > if !ok {

209 return nil, fmt.Errorf("%w: state machine for type: %v", ErrNotRegistered, t)

210 }

211 > serialized, err := def.Serialize(data) tree.go

212 > if err != nil {

213 return nil, err

214 }

215 > return &Node{ tree.go

216 > definition: def,

217 > registry: registry,

218 > persistence: &persistencespb.StateMachineNode{

219 > Children: children,

220 > Data: serialized,

221 > InitialVersionedTransition: &persistencespb.VersionedTransition{},

222 > LastUpdateVersionedTransition: &persistencespb.VersionedTransition{},

223 > TransitionCount: 0,

224 > },

225 > cache: &cachedMachine{

226 > dataLoaded: true,

227 > data: data,

228 > children: make(map[Key]*Node),

229 > },

230 > backend: backend,

231 > opLog: make(OperationLog, 0),

232 > }, nil

233 }

234

235 // Dirty returns true if any of the tree's state machines have transitioned.

236 > func (n *Node) Dirty() bool { tree.go

237 > if n.cache.dirty {

238 > return true tree.go

239 > }

240 > for _, child := range n.cache.children { tree.go

241 > if child.Dirty() { tree.go

242 > return true tree.go

243 > }

244 }

245 > return false tree.go

246 }

247

251 }

252

253 > func (n *Node) Path() []Key { tree.go

254 > if n.Parent == nil {

255 > return []Key{}

256 > }

257 > return append(n.Parent.Path(), n.Key) tree.go

258 }

259

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

282 > }

283 }

284

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

298 > for _, child := range childNodes {

299 > if err := child.Walk(fn); err != nil {

300 return err

301 }

303 }

304

305 > return nil tree.go

306 }

307

308 // Child recursively gets a child for the given path.

309 > func (n *Node) Child(path []Key) (*Node, error) { tree.go

310 > if len(path) == 0 {

311 > return n, nil tree.go

312 > }

313 > key, rest := path[0], path[1:] tree.go

314 > if child, ok := n.cache.children[key]; ok {

315 > return child.Child(rest) tree.go

316 > }

317 > def, ok := n.registry.Machine(key.Type) tree.go

318 > if !ok {

319 return nil, fmt.Errorf("%w: state machine for type: %v", ErrNotRegistered, key.Type)

320 }

321 > machines, ok := n.persistence.Children[key.Type] tree.go

322 > if !ok {

323 return nil, fmt.Errorf("%w: %v", ErrStateMachineNotFound, key)

324 }

325 > machine, ok := machines.MachinesById[key.ID] tree.go

326 > if !ok {

327 return nil, fmt.Errorf("%w: %v", ErrStateMachineNotFound, key)

328 }

329 > child := &Node{ tree.go

330 > Key: key,

331 > Parent: n,

332 > registry: n.registry,

333 > definition: def,

334 > cache: &cachedMachine{

335 > children: make(map[Key]*Node),

336 > },

337 > persistence: machine,

338 > backend: n.backend,

339 > }

340 > n.cache.children[key] = child

341 > return child.Child(rest)

342 }

343

466 // MachineData deserializes the persistent state machine's data, casts it to type T, and returns it.

467 // Returns an error when deserialization or casting fails.

468 > func MachineData[T any](n *Node) (T, error) { tree.go

469 > var t T

470 > if n.cache.dataLoaded {

471 if t, ok := n.cache.data.(T); ok {

472 return t, nil

474 return t, ErrIncompatibleType

475 }

476 > a, err := n.definition.Deserialize(n.persistence.Data) tree.go

477 > if err != nil {

478 return t, err

479 }

480 > n.cache.data = a tree.go

481 > n.cache.dataLoaded = true

482 >

483 > if t, ok := a.(T); ok {

484 > return t, nil

485 > }

486 return t, ErrIncompatibleType

487 }

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.

539 // Sync updates the state of the current node to that of the incoming node.

540 // Meant to be used by the framework, **not** by components.

541 > func (n *Node) Sync(incomingNode *Node) error { tree.go

542 > incomingInternalRepr := incomingNode.InternalRepr()

543 >

544 > currentInitialVersionedTransition := n.InternalRepr().InitialVersionedTransition

545 > incomingInitialVersionedTransition := incomingNode.InternalRepr().InitialVersionedTransition

546 > if currentInitialVersionedTransition.NamespaceFailoverVersion !=

547 > incomingInitialVersionedTransition.NamespaceFailoverVersion {

548 return ErrInitialTransitionMismatch

549 }

550 > if currentInitialVersionedTransition.TransitionCount != 0 && tree.go

551 > incomingInitialVersionedTransition.TransitionCount != 0 &&

552 > currentInitialVersionedTransition.TransitionCount !=

553 > incomingInitialVersionedTransition.TransitionCount {

554 return ErrInitialTransitionMismatch

555 }

556

557 > n.persistence.Data = incomingInternalRepr.Data tree.go

558 > // do not sync children, we are just syncing the current node

559 > // do not sync transitionCount, that is cluster local information

560 >

561 > // force reload data

562 > n.cache.dataLoaded = false

563 >

564 > // reuse MachineTransition for

565 > // - marking the node as dirty

566 > // - generate transition outputs (tasks)

567 > // - update transition count

568 > if err := MachineTransition(n, func(taskRegenerator TaskRegenerator) (TransitionOutput, error) {

569 > tasks, err := taskRegenerator.RegenerateTasks(n)

570 > return TransitionOutput{

571 > Tasks: tasks,

572 > }, err

573 > }); err != nil {

574 return err

575 }

576

577 // sync LastUpdateVersionedTransition last as MachineTransition can't correctly handle it.

578 > n.persistence.LastUpdateVersionedTransition = incomingInternalRepr.LastUpdateVersionedTransition tree.go

579 > return nil

580 }

581

583 // It updates the state machine's metadata and marks the entry as dirty in the node's cache.

584 // If the transition fails, the changes are rolled back and no state is mutated.

585 > func MachineTransition[T any](n *Node, transitionFn func(T) (TransitionOutput, error)) (retErr error) { tree.go

586 > if n.cache.deleted {

587 return fmt.Errorf("%w: cannot transition deleted node: %v", ErrStateMachineInvalidState, n.Key)

588 }

589

590 > data, err := MachineData[T](n) tree.go

591 > if err != nil {

592 return err

593 }

594 // Update the transition counts before applying the transition function in case the transition function needs to

595 // generate references to this node.

596 > n.persistence.TransitionCount++ tree.go

597 > prevLastUpdatedVersionedTransition := n.persistence.LastUpdateVersionedTransition

598 > n.persistence.LastUpdateVersionedTransition = &persistencespb.VersionedTransition{

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

600 > // The transition count for the backend is only incremented when closing the current transaction,

601 > // but any change to state machine node is a state transtion,

602 > // so we can safely using next transition count here.

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

604 > }

605 > // Rollback on error

606 > defer func() {

607 > if retErr != nil {

608 n.persistence.TransitionCount--

609 n.persistence.LastUpdateVersionedTransition = prevLastUpdatedVersionedTransition

612 }

613 }()

614 > output, err := transitionFn(data) tree.go

615 > if err != nil {

616 return err

617 }

618 > serialized, err := n.definition.Serialize(data) tree.go

619 > if err != nil {

620 return err

621 }

622 > n.persistence.Data = serialized tree.go

623 > n.cache.dirty = true

624 >

625 > root := n.root()

626 > root.opLog = append(root.opLog, TransitionOperation{

627 > path: n.Path(),

628 > Output: TransitionOutputWithCount{

629 > TransitionOutput: output,

630 > TransitionCount: n.persistence.TransitionCount,

631 > },

632 > })

633 >

634 > return nil

635 }

636

643

644 // NewCollection creates a new [Collection].

645 > func NewCollection[T any](node *Node, stateMachineType string) Collection[T] { tree.go

646 > return Collection[T]{

647 > Type: stateMachineType,

648 > node: node,

649 > }

650 > }

651

652 // Node gets an [Node] for a given state machine ID.

656

657 // List returns all nodes in this collection.

658 > func (c Collection[T]) List() []*Node { tree.go

659 > machines, ok := c.node.persistence.Children[c.Type]

660 > if !ok {

661 return nil

662 }

663 > nodes := make([]*Node, 0, len(machines.MachinesById)) tree.go

664 > for id := range machines.MachinesById {

665 > node, err := c.node.Child([]Key{{Type: c.Type, ID: id}})

666 > if err != nil {

667 panic("expected child to be present")

668 }

669 > nodes = append(nodes, node) tree.go

670 }

671 > return nodes tree.go

672 }

673

705 }

706

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

708 > root := n

709 > for root.Parent != nil {

710 > root = root.Parent tree.go

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

732 }

733

734 > root := newOpNode(Key{}) tree.go

735 > for _, op := range ol {

736 > node := root.getOrCreateNode(op.Path())

737 > if _, ok := op.(DeleteOperation); ok {

738 node.isDeleted = true

739 }

740 }

741

742 > return root.collect(ol) tree.go

743 }

744

745 // getOrCreateNode traverses/creates path and returns the final node.

746 > func (n *opNode) getOrCreateNode(path []Key) *opNode { tree.go

747 > current := n

748 > for _, key := range path {

749 > next, exists := current.children[key] tree.go

750 > if !exists {

751 > next = newOpNode(key)

752 > current.children[key] = next

753 > }

754 > current = next

755 }

756 > return current tree.go

757 }

758

773

774 // newOpNode creates a new operation tree node with the given key.

775 > func newOpNode(key Key) *opNode { tree.go

776 > return &opNode{

777 > key: key,

778 > children: make(map[Key]*opNode),

779 > }

780 > }

781

782 // collect returns an ordered subset of the input operation log based on the deletion status tracked in this operation

783 // tree. The original chronological order of operations is preserved. The status of each node in the path (not just the

784 // operation's target) determines whether the operation is included in the result.

785 > func (n *opNode) collect(oplog OperationLog) OperationLog { tree.go

786 > var result OperationLog

787 >

788 > for _, op := range oplog {

789 > path := op.Path()

790 > current := n

791 >

792 > var isAncestorDeleted bool

793 >

794 > // Traverse the path to the target node, checking deletion status

795 > for i, key := range path {

796 > child, exists := current.children[key] tree.go

797 > if !exists {

798 panic("path must exist in tree")

799 }

800

801 > if child.isDeleted { tree.go

802 isAncestorDeleted = true

803 if i == len(path)-1 {

808 break

809 }

810 > current = child tree.go

811 }

812

813 > if isAncestorDeleted { tree.go

814 continue

815 }

816

817 > result = append(result, op) tree.go

818 }

819

820 > return result tree.go

821 }

go.temporal.io/server/service/history/workflow/context.go 185 covered LOC · 50 ranges

Open complete file

88 throttledLogger log.ThrottledLogger,

89 metricsHandler metrics.Handler,

90 > ) *ContextImpl { context.go

91 > tags := func() []tag.Tag {

92 return []tag.Tag{

93 tag.WorkflowNamespaceID(workflowKey.NamespaceID),

96 }

97 }

98 > contextImpl := &ContextImpl{ context.go

99 > workflowKey: workflowKey,

100 > archetypeID: archetypeID,

101 > logger: log.NewLazyLogger(logger, tags),

102 > throttledLogger: log.NewLazyLogger(throttledLogger, tags),

103 > metricsHandler: metricsHandler.WithTags(metrics.OperationTag(metrics.WorkflowContextScope)),

104 > config: config,

105 > lock: locks.NewPrioritySemaphore(1),

106 > }

107 > softassert.That(

108 > contextImpl.throttledLogger,

109 > contextImpl.archetypeID != chasm.UnspecifiedArchetypeID,

110 > "Creating execution context with unspecified archetype ID",

111 > )

112 >

113 > return contextImpl

114 }

115

117 ctx context.Context,

118 lockPriority locks.Priority,

119 > ) error { context.go

120 > return c.lock.Acquire(ctx, lockPriority, 1)

121 > }

122

123 > func (c *ContextImpl) Unlock() { context.go

124 > c.lock.Release(1)

125 > }

126

127 > func (c *ContextImpl) IsDirty() bool { context.go

128 > if c.MutableState == nil {

129 return false

130 }

131 > return c.MutableState.IsDirty() context.go

132 }

133

177 // task is no longer in flight (timed out, failed, completed, or the workflow

178 // closed) and its buffer can never be consumed

179 > func (c *ContextImpl) reconcileTaskCompletionBuffer() { context.go

180 > if c.taskCompletionBuffer == nil || c.MutableState == nil {

181 > return context.go

182 > }

183 if c.startedWorkflowTaskIdentity() != c.taskCompletionBuffer.identity {

184 c.clearTaskCompletionBuffer()

323 }

324

325 > func (c *ContextImpl) GetNamespace(shardContext historyi.ShardContext) namespace.Name { context.go

326 > namespaceEntry, err := shardContext.GetNamespaceRegistry().GetNamespaceByID(

327 > namespace.ID(c.workflowKey.NamespaceID),

328 > )

329 > if err != nil {

330 return ""

331 }

332 > return namespaceEntry.Name() context.go

333 }

334

341 }

342

343 > func (c *ContextImpl) LoadMutableState(ctx context.Context, shardContext historyi.ShardContext) (historyi.MutableState, error) { context.go

344 > namespaceEntry, err := shardContext.GetNamespaceRegistry().GetNamespaceByID(

345 > namespace.ID(c.workflowKey.NamespaceID),

346 > )

347 > if err != nil {

348 return nil, err

349 }

350

351 > if c.MutableState == nil { context.go

352 > response, err := getWorkflowExecution(ctx, shardContext, &persistence.GetWorkflowExecutionRequest{ context.go

353 > ShardID: shardContext.GetShardID(),

354 > NamespaceID: c.workflowKey.NamespaceID,

355 > WorkflowID: c.workflowKey.WorkflowID,

356 > RunID: c.workflowKey.RunID,

357 > ArchetypeID: c.archetypeID,

358 > })

359 > if err != nil {

360 return nil, err

361 }

362

363 > mutableState, err := NewMutableStateFromDB( context.go

364 > shardContext,

365 > shardContext.GetEventsCache(),

366 > c.logger,

367 > namespaceEntry,

368 > response.State,

369 > response.DBRecordVersion,

370 > )

371 > if err != nil {

372 return nil, err

373 }

378 // returned by NewMutableStateFromDB().

379 // Thus causing NPE (e.g. when calling c.Clear()) or other unexpected behavior.

380 > c.MutableState = mutableState context.go

381 }

382

383 > mutableStateArchetypeID := c.MutableState.ChasmTree().ArchetypeID() context.go

384 > if c.archetypeID != chasm.UnspecifiedArchetypeID && c.archetypeID != mutableStateArchetypeID {

385 chasmRegistry := shardContext.ChasmRegistry()

386 contextArchetype, ok := chasmRegistry.ComponentFqnByID(c.archetypeID)

405 )

406 }

407 > c.archetypeID = mutableStateArchetypeID context.go

408 >

409 > flushBeforeReady, err := c.MutableState.StartTransaction(namespaceEntry)

410 > if err != nil {

411 return nil, err

412 }

413 > if !flushBeforeReady { context.go

414 > return c.MutableState, nil

415 > }

416

417 if err = c.UpdateWorkflowExecutionAsActive(

708 ctx context.Context,

709 shardContext historyi.ShardContext,

710 > ) error { context.go

711 >

712 > updateMode, err := c.updateWorkflowMode()

713 > if err != nil {

714 return err

715 }

716

717 > return c.UpdateWorkflowExecutionWithNew( context.go

718 > ctx,

719 > shardContext,

720 > updateMode,

721 > nil,

722 > nil,

723 > historyi.TransactionPolicyPassive,

724 > nil,

725 > )

726 }

727

752 updateWorkflowTransactionPolicy historyi.TransactionPolicy,

753 newWorkflowTransactionPolicy *historyi.TransactionPolicy,

754 > ) (retError error) { context.go

755 >

756 > defer func() {

757 > if retError != nil {

758 c.Clear()

759 }

760 }()

761

762 > if newContext != nil && newMutableState != nil && newWorkflowTransactionPolicy != nil { context.go

763 if *newWorkflowTransactionPolicy == historyi.TransactionPolicyActive {

764 execInfo := newMutableState.GetExecutionInfo()

784 // reconcileTaskCompletionBuffer drops an orphaned buffer for the pagination of

785 // RespondWorkflowTaskCompleted requests.

786 > c.reconcileTaskCompletionBuffer() context.go

787 >

788 > updateWorkflow, updateWorkflowEventsSeq, err := c.MutableState.CloseTransactionAsMutation(

789 > ctx,

790 > updateWorkflowTransactionPolicy,

791 > )

792 > if err != nil {

793 return err

794 }

795

796 > var newWorkflow *persistence.WorkflowSnapshot context.go

797 > var newWorkflowEventsSeq []*persistence.WorkflowEvents

798 > if newContext != nil && newMutableState != nil && newWorkflowTransactionPolicy != nil {

799 defer func() {

800 if retError != nil {

812 }

813

814 > if updateWorkflow == nil { context.go

815 if newWorkflow != nil || len(newWorkflowEventsSeq) != 0 {

816 return serviceerror.NewInternal("current workflow mutation skipped with new workflow snapshot")

819 }

820

821 > if err := c.mergeUpdateWithNewReplicationTasks( context.go

822 > updateWorkflow,

823 > newWorkflow,

824 > ); err != nil {

825 return err

826 }

827

828 > eventsToReapply := updateWorkflowEventsSeq context.go

829 > if len(updateWorkflowEventsSeq) == 0 {

830 > if reapplyCandidateEvents := c.MutableState.GetReapplyCandidateEvents(); len(reapplyCandidateEvents) != 0 { context.go

831 eventsToReapply = []*persistence.WorkflowEvents{

832 {

840 }

841

842 > if err := c.updateWorkflowExecutionEventReapply( context.go

843 > ctx,

844 > shardContext,

845 > updateMode,

846 > eventsToReapply,

847 > // The new run is created by applying events so the history builder in newMutableState contains the events be re-applied.

848 > // So we can use newWorkflowEventsSeq directly to reapply events.

849 > newWorkflowEventsSeq,

850 > ); err != nil {

851 return err

852 }

853

854 > if _, _, err := NewTransaction(shardContext).UpdateWorkflowExecution( context.go

855 > ctx,

856 > updateMode,

857 > c.archetypeID,

858 > c.MutableState.GetCurrentVersion(),

859 > updateWorkflow,

860 > updateWorkflowEventsSeq,

861 > MutableStateFailoverVersion(newMutableState),

862 > newWorkflow,

863 > newWorkflowEventsSeq,

864 > c.MutableState.IsWorkflow(),

865 > ); err != nil {

866 return err

867 }

868

869 > emitStateTransitionCount(c.metricsHandler, shardContext.GetClusterMetadata(), c.MutableState) context.go

870 > emitStateTransitionCount(c.metricsHandler, shardContext.GetClusterMetadata(), newMutableState)

871 >

872 > // finally emit session stats

873 > emitWorkflowHistoryStats(

874 > c.metricsHandler,

875 > c.GetNamespace(shardContext),

876 > c.MutableState.GetExecutionState().State,

877 > int(c.MutableState.GetExecutionInfo().ExecutionStats.HistorySize),

878 > int(c.MutableState.GetNextEventID()-1),

879 > )

880 >

881 > return nil

882 }

883

926 currentWorkflowMutation *persistence.WorkflowMutation,

927 newWorkflowSnapshot *persistence.WorkflowSnapshot,

928 > ) error { context.go

929 >

930 > if newWorkflowSnapshot == nil {

931 > return nil context.go

932 > }

933

934 if currentWorkflowMutation.ExecutionState.Status != enumspb.WORKFLOW_EXECUTION_STATUS_CONTINUED_AS_NEW &&

1043 eventBatch1 []*persistence.WorkflowEvents,

1044 eventBatch2 []*persistence.WorkflowEvents,

1045 > ) error { context.go

1046 > if updateMode == persistence.UpdateWorkflowModeIgnoreCurrent {

1047 if len(eventBatch1) != 0 || len(eventBatch2) != 0 {

1048 return serviceerror.NewInternal("encountered events reapplication without knowing if workflow is current. Events generated for a close workflow?")

1051 }

1052

1053 > if updateMode != persistence.UpdateWorkflowModeBypassCurrent { context.go

1054 > return nil context.go

1055 > }

1056

1057 var eventBatches []*persistence.WorkflowEvents

1079 }

1080

1081 > func (c *ContextImpl) updateWorkflowMode() (persistence.UpdateWorkflowMode, error) { context.go

1082 > if !c.config.EnableUpdateWorkflowModeIgnoreCurrent() {

1083 return persistence.UpdateWorkflowModeUpdateCurrent, nil

1084 }

1085

1086 > if c.MutableState.IsCurrentWorkflowGuaranteed() { context.go

1087 > return persistence.UpdateWorkflowModeUpdateCurrent, nil context.go

1088 > }

1089

1090 guaranteed, err := c.MutableState.IsNonCurrentWorkflowGuaranteed()

1418 // CacheSize estimates the in-memory size of the object for cache limits. For proto objects, it uses proto.Size()

1419 // which returns the serialized size. Note: In-memory size will be slightly larger than the serialized size.

1420 > func (c *ContextImpl) CacheSize() int { context.go

1421 > if !c.config.HistoryCacheLimitSizeBased {

1422 > return 1 context.go

1423 > }

1424 size := len(c.workflowKey.WorkflowID) + len(c.workflowKey.RunID) + len(c.workflowKey.NamespaceID)

1425 if c.MutableState != nil {

1436 clusterMetadata cluster.Metadata,

1437 mutableState historyi.MutableState,

1438 > ) { context.go

1439 > if mutableState == nil {

1440 > return context.go

1441 > }

1442 > namespaceEntry := mutableState.GetNamespaceEntry() context.go

1443 > metrics.StateTransitionCount.With(metricsHandler).Record(

1444 > mutableState.GetExecutionInfo().StateTransitionCount,

1445 > metrics.NamespaceTag(namespaceEntry.Name().String()),

1446 > metrics.NamespaceStateTag(namespaceState(clusterMetadata, new(mutableState.GetCurrentVersion()))),

1447 > )

1448 }

1449

1451 clusterMetadata cluster.Metadata,

1452 mutableStateCurrentVersion *int64,

1453 > ) string { context.go

1454 >

1455 > if mutableStateCurrentVersion == nil {

1456 > return metrics.UnknownNamespaceStateTagValue context.go

1457 > }

1458

1459 // default value, need to special handle

1460 > if *mutableStateCurrentVersion == 0 { context.go

1461 return metrics.ActiveNamespaceStateTagValue

1462 }

1463

1464 > if clusterMetadata.IsVersionFromSameCluster( context.go

1465 > clusterMetadata.GetClusterID(),

1466 > *mutableStateCurrentVersion,

1467 > ) {

1468 > return metrics.ActiveNamespaceStateTagValue

1469 > }

1470 return metrics.PassiveNamespaceStateTagValue

1471 }

1473 func MutableStateFailoverVersion(

1474 mutableState historyi.MutableState,

1475 > ) *int64 { context.go

1476 > if mutableState == nil {

1477 > return nil context.go

1478 > }

1479 return new(mutableState.GetCurrentVersion())

1480 }

go.temporal.io/server/service/history/workflow/transaction_impl.go 182 covered LOC · 32 ranges

Open complete file

40 func NewTransaction(

41 shardContext historyi.ShardContext,

42 > ) *TransactionImpl { transaction_impl.go

43 > return &TransactionImpl{

44 > shard: shardContext,

45 > logger: shardContext.GetLogger(),

46 > }

47 > }

48

49 func (t *TransactionImpl) CreateWorkflowExecution(

172 newWorkflowEventsSeq []*persistence.WorkflowEvents,

173 isWorkflow bool,

174 > ) (int64, int64, error) { transaction_impl.go

175 >

176 > engine, err := t.shard.GetEngine(ctx)

177 > if err != nil {

178 return 0, 0, err

179 }

180 > resp, err := updateWorkflowExecution( transaction_impl.go

181 > ctx,

182 > t.shard,

183 > currentWorkflowFailoverVersion,

184 > newWorkflowFailoverVersion,

185 > &persistence.UpdateWorkflowExecutionRequest{

186 > ShardID: t.shard.GetShardID(),

187 > // RangeID , this is set by shard context

188 > Mode: updateMode,

189 > ArchetypeID: archetypeID,

190 > UpdateWorkflowMutation: *currentWorkflowMutation,

191 > UpdateWorkflowEvents: currentWorkflowEventsSeq,

192 > NewWorkflowSnapshot: newWorkflowSnapshot,

193 > NewWorkflowEvents: newWorkflowEventsSeq,

194 > },

195 > isWorkflow,

196 > )

197 > if persistence.OperationPossiblySucceeded(err) {

198 > NotifyOnExecutionMutation(engine, currentWorkflowMutation) transaction_impl.go

199 > NotifyOnExecutionSnapshot(engine, newWorkflowSnapshot)

200 > }

201 > if err != nil { transaction_impl.go

202 return 0, 0, err

203 }

204

205 > if err := NotifyNewHistoryMutationEvent(engine, currentWorkflowMutation); err != nil { transaction_impl.go

206 t.logger.Error("unable to notify workflow mutation", tag.Error(err))

207 }

208 > if err := NotifyNewHistorySnapshotEvent(engine, newWorkflowSnapshot); err != nil { transaction_impl.go

209 t.logger.Error("unable to notify workflow creation", tag.Error(err))

210 }

211 > updateHistorySizeDiff := int64(resp.UpdateMutableStateStats.HistoryStatistics.SizeDiff) transaction_impl.go

212 > newHistorySizeDiff := int64(0)

213 > if resp.NewMutableStateStats != nil {

214 newHistorySizeDiff = int64(resp.NewMutableStateStats.HistoryStatistics.SizeDiff)

215 }

216 > return updateHistorySizeDiff, newHistorySizeDiff, nil transaction_impl.go

217 }

218

474 shardContext historyi.ShardContext,

475 request *persistence.GetWorkflowExecutionRequest,

476 > ) (*persistence.GetWorkflowExecutionResponse, error) { transaction_impl.go

477 >

478 > resp, err := shardContext.GetWorkflowExecution(ctx, request)

479 > if err != nil {

480 switch err.(type) {

481 case *serviceerror.NotFound:

495 }

496

497 > if namespaceEntry, err := shardContext.GetNamespaceRegistry().GetNamespaceByID( transaction_impl.go

498 > namespace.ID(resp.State.ExecutionInfo.NamespaceId),

499 > ); err == nil {

500 > emitGetMetrics(

501 > shardContext,

502 > namespaceEntry,

503 > request.ArchetypeID,

504 > &resp.MutableStateStats,

505 > )

506 > }

507 > return resp, nil

508 }

509

515 request *persistence.UpdateWorkflowExecutionRequest,

516 isWorkflow bool,

517 > ) (*persistence.UpdateWorkflowExecutionResponse, error) { transaction_impl.go

518 >

519 > resp, err := shardContext.UpdateWorkflowExecution(ctx, request)

520 > if err != nil {

521 shardContext.GetLogger().Error(

522 "Update workflow execution operation failed.",

530 }

531

532 > if namespaceEntry, err := shardContext.GetNamespaceRegistry().GetNamespaceByID( transaction_impl.go

533 > namespace.ID(request.UpdateWorkflowMutation.ExecutionInfo.NamespaceId),

534 > ); err == nil {

535 > emitMutationMetrics(

536 > shardContext,

537 > namespaceEntry,

538 > request.ArchetypeID,

539 > &resp.UpdateMutableStateStats,

540 > resp.NewMutableStateStats,

541 > )

542 >

543 > emitCompletionMetrics(

544 > shardContext,

545 > namespaceEntry,

546 > mutationToCompletionMetric(

547 > namespaceState(shardContext.GetClusterMetadata(), &updateWorkflowFailoverVersion),

548 > &request.UpdateWorkflowMutation,

549 > request.UpdateWorkflowEvents,

550 > isWorkflow,

551 > ),

552 > snapshotToCompletionMetric(

553 > namespaceState(shardContext.GetClusterMetadata(), newWorkflowFailoverVersion),

554 > request.NewWorkflowSnapshot,

555 > request.NewWorkflowEvents,

556 > isWorkflow,

557 > ),

558 > )

559 > }

560

561 > return resp, nil transaction_impl.go

562 }

563

586 engine historyi.Engine,

587 workflowSnapshot *persistence.WorkflowSnapshot,

588 > ) { transaction_impl.go

589 > if workflowSnapshot == nil {

590 > return transaction_impl.go

591 > }

592 engine.NotifyNewTasks(workflowSnapshot.Tasks)

593 if len(workflowSnapshot.ChasmNodes) > 0 {

603 engine historyi.Engine,

604 workflowMutation *persistence.WorkflowMutation,

605 > ) { transaction_impl.go

606 > if workflowMutation == nil {

607 return

608 }

609 > engine.NotifyNewTasks(workflowMutation.Tasks) transaction_impl.go

610 > if len(workflowMutation.UpsertChasmNodes) > 0 ||

611 > len(workflowMutation.DeleteChasmNodes) > 0 {

612 engine.NotifyChasmExecution(chasm.ExecutionKey{

613 NamespaceID: workflowMutation.ExecutionInfo.NamespaceId,

621 engine historyi.Engine,

622 workflowSnapshot *persistence.WorkflowSnapshot,

623 > ) error { transaction_impl.go

624 >

625 > if workflowSnapshot == nil {

626 > return nil transaction_impl.go

627 > }

628

629 executionInfo := workflowSnapshot.ExecutionInfo

661 engine historyi.Engine,

662 workflowMutation *persistence.WorkflowMutation,

663 > ) error { transaction_impl.go

664 >

665 > if workflowMutation == nil {

666 return nil

667 }

668

669 > executionInfo := workflowMutation.ExecutionInfo transaction_impl.go

670 > executionState := workflowMutation.ExecutionState

671 >

672 > namespaceID := executionInfo.NamespaceId

673 > workflowID := executionInfo.WorkflowId

674 > runID := executionState.RunId

675 > workflowState := executionState.State

676 > workflowStatus := executionState.Status

677 > lastFirstEventID := executionInfo.LastFirstEventId

678 > lastFirstEventTxnID := executionInfo.LastFirstEventTxnId

679 > lastWorkflowTaskStartEventID := executionInfo.LastCompletedWorkflowTaskStartedEventId

680 > nextEventID := workflowMutation.NextEventID

681 >

682 > engine.NotifyNewHistoryEvent(events.NewNotification(

683 > namespaceID,

684 > &commonpb.WorkflowExecution{

685 > WorkflowId: workflowID,

686 > RunId: runID,

687 > },

688 > lastFirstEventID,

689 > lastFirstEventTxnID,

690 > nextEventID,

691 > lastWorkflowTaskStartEventID,

692 > workflowState,

693 > workflowStatus,

694 > executionInfo.VersionHistories,

695 > executionInfo.TransitionHistory,

696 > ))

697 > return nil

698 }

699

703 archetypeID chasm.ArchetypeID,

704 stats ...*persistence.MutableStateStatistics,

705 > ) { transaction_impl.go

706 > metricsHandler := shardContext.GetMetricsHandler()

707 > chasmRegistry := shardContext.ChasmRegistry()

708 > namespaceName := namespace.Name()

709 > for _, stat := range stats {

710 > emitMutableStateStatus(

711 > metricsHandler.WithTags(metrics.OperationTag(metrics.SessionStatsScope), metrics.NamespaceTag(namespaceName.String())),

712 > chasmRegistry,

713 > archetypeID,

714 > stat,

715 > )

716 > }

717 }

718

722 archetypeID chasm.ArchetypeID,

723 stats ...*persistence.MutableStateStatistics,

724 > ) { transaction_impl.go

725 > metricsHandler := shardContext.GetMetricsHandler()

726 > chasmRegistry := shardContext.ChasmRegistry()

727 > namespaceName := namespace.Name()

728 > for _, stat := range stats {

729 > emitMutableStateStatus(

730 > metricsHandler.WithTags(metrics.OperationTag(metrics.ExecutionStatsScope), metrics.NamespaceTag(namespaceName.String())),

731 > chasmRegistry,

732 > archetypeID,

733 > stat,

734 > )

735 > }

736 }

737

738 // wroteEvents reports whether the run wrote any history events in this transaction.

739 > func wroteEvents(eventsSeq []*persistence.WorkflowEvents) bool { transaction_impl.go

740 > for _, batch := range eventsSeq {

741 if len(batch.Events) > 0 {

742 return true

743 }

744 }

745 > return false transaction_impl.go

746 }

747

751 eventsSeq []*persistence.WorkflowEvents,

752 isWorkflow bool,

753 > ) completionMetric { transaction_impl.go

754 > if workflowSnapshot == nil {

755 > return completionMetric{shouldRecord: false} transaction_impl.go

756 > }

757

758 return completionMetric{

774 eventsSeq []*persistence.WorkflowEvents,

775 isWorkflow bool,

776 > ) completionMetric { transaction_impl.go

777 > if workflowMutation == nil {

778 return completionMetric{shouldRecord: false}

779 }

780

781 > return completionMetric{ transaction_impl.go

782 > shouldRecord: wroteEvents(eventsSeq),

783 > isWorkflow: isWorkflow,

784 > taskQueue: workflowMutation.ExecutionInfo.TaskQueue,

785 > namespaceState: namespaceState,

786 > workflowTypeName: workflowMutation.ExecutionInfo.WorkflowTypeName,

787 > status: workflowMutation.ExecutionState.Status,

788 > startTime: workflowMutation.ExecutionState.StartTime,

789 > closeTime: workflowMutation.ExecutionInfo.CloseTime,

790 > }

791 }

792

795 namespace *namespace.Namespace,

796 completionMetrics ...completionMetric,

797 > ) { transaction_impl.go

798 > metricsHandler := shardContext.GetMetricsHandler()

799 > namespaceName := namespace.Name()

800 >

801 > for _, completionMetric := range completionMetrics {

802 > if !completionMetric.shouldRecord {

803 > continue transaction_impl.go

804 }

805

go.temporal.io/server/common/metrics/tally_metrics_handler.go 139 covered LOC · 39 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 { tally_metrics_handler.go

48 > c.mu.RLock()

49 > if s, ok := c.scopes[key]; ok {

50 c.mu.RUnlock()

51 return s

52 }

53 > c.mu.RUnlock() tally_metrics_handler.go

54 >

55 > s := create()

56 >

57 > c.mu.Lock()

58 > defer c.mu.Unlock()

59 > // Double-check: another goroutine may have inserted while we were creating.

60 > if existing, ok := c.scopes[key]; ok {

61 return existing

62 }

63 > if len(c.scopes) >= c.maxSize { tally_metrics_handler.go

64 clear(c.scopes)

65 }

66 > c.scopes[key] = s tally_metrics_handler.go

67 > return s

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)) tally_metrics_handler.go

185 > return tmh.cache.loadOrStoreScope(key, func() tally.Scope {

186 > return tmh.scope.Tagged(tagsToMap(tags, tmh.excludeTags))

187 > })

188 }

189

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

273 func (*tallyMetricsHandler) Stop(log.Logger) {}

274

275 > func (*tallyMetricsHandler) Close() error { tally_metrics_handler.go

276 > return nil

277 > }

278

279 > func (tmh *tallyMetricsHandler) StartBatch(_ string) BatchHandler { tally_metrics_handler.go

280 > return tmh

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/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 126 covered LOC · 26 ranges

Open complete file

83 }

84

85 > func (x *ShardInfo) GetShardId() int32 { executions.pb.go

86 > if x != nil {

87 > return x.ShardId

88 > }

89 return 0

90 }

91

92 > func (x *ShardInfo) GetRangeId() int64 { executions.pb.go

93 > if x != nil {

94 > return x.RangeId

95 > }

96 return 0

97 }

98

99 > func (x *ShardInfo) GetOwner() string { executions.pb.go

100 > if x != nil {

101 > return x.Owner

102 > }

103 return ""

104 }

393 func (*WorkflowExecutionInfo) ProtoMessage() {}

394

395 > func (x *WorkflowExecutionInfo) ProtoReflect() protoreflect.Message { executions.pb.go

396 > mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[1]

397 > if x != nil {

398 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) executions.pb.go

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

400 > ms.StoreMessageInfo(mi)

401 > }

402 > return ms

403 }

404 return mi.MessageOf(x)

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 }

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

1563 if ms.LoadMessageInfo() == nil {

1566 return ms

1567 }

1568 > return mi.MessageOf(x) executions.pb.go

1569 }

1570

3726 }

3727

3728 > func (x *Checksum) GetValue() []byte { executions.pb.go

3729 > if x != nil {

3730 return x.Value

3731 }

3732 > return nil executions.pb.go

3733 }

3734

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/service/history/workflow/cache/cache.go 125 covered LOC · 32 ranges

Open complete file

95 logger log.Logger,

96 handler metrics.Handler,

97 > ) Cache { cache.go

98 > maxSize := config.HistoryHostLevelCacheMaxSize()

99 > if config.HistoryCacheLimitSizeBased {

100 maxSize = config.HistoryHostLevelCacheMaxSizeBytes()

101 }

102 > opts := &cache.Options{ cache.go

103 > TTL: config.HistoryCacheTTL(),

104 > Pin: true,

105 > BackgroundEvict: config.HistoryCacheBackgroundEvict,

106 > OnPut: func(val any) {

107 > //revive:disable-next-line:unchecked-type-assertion cache.go

108 > item := val.(*cacheItem)

109 > if item.finalizer == nil {

110 > return // should only happen in unit tests cache.go

111 > }

112 wfKey := item.wfContext.GetWorkflowKey()

113 err := item.finalizer.Register(wfKey.String(), func(ctx context.Context) error {

141 }

142

143 > taggedHandler := handler.WithTags(metrics.CacheTypeTag(metrics.MutableStateCacheTypeTagValue)) cache.go

144 > c := cache.NewWithMetrics(maxSize, opts, taggedHandler)

145 > return &cacheImpl{

146 > Cache: c,

147 > nonUserContextLockTimeout: config.HistoryCacheNonUserContextLockTimeout(),

148 > }

149 }

150

159 execution *commonpb.WorkflowExecution,

160 lockPriority locks.Priority,

161 > ) (historyi.WorkflowContext, historyi.ReleaseWorkflowContextFunc, error) { cache.go

162 > return c.GetOrCreateChasmExecution(

163 > ctx,

164 > shardContext,

165 > namespaceID,

166 > execution,

167 > chasm.WorkflowArchetypeID,

168 > lockPriority,

169 > )

170 > }

171

172 func (c *cacheImpl) GetOrCreateCurrentExecution(

221 archetypeID chasm.ArchetypeID,

222 lockPriority locks.Priority,

223 > ) (historyi.WorkflowContext, historyi.ReleaseWorkflowContextFunc, error) { cache.go

224 >

225 > if err := c.validateWorkflowExecutionInfo(ctx, shardContext, namespaceID, execution, archetypeID, lockPriority); err != nil {

226 return nil, nil, err

227 }

228

229 > handler := shardContext.GetMetricsHandler().WithTags( cache.go

230 > metrics.OperationTag(metrics.HistoryCacheGetOrCreateScope),

231 > metrics.CacheTypeTag(metrics.MutableStateCacheTypeTagValue),

232 > metrics.NamespaceIDTag(namespaceID.String()),

233 > )

234 > metrics.CacheRequests.With(handler).Record(1)

235 > start := time.Now()

236 > defer func() { metrics.CacheLatency.With(handler).Record(time.Since(start)) }()

237

238 > weCtx, weReleaseFunc, err := c.getOrCreateWorkflowExecutionInternal( cache.go

239 > ctx,

240 > shardContext,

241 > namespaceID,

242 > execution,

243 > archetypeID,

244 > handler,

245 > false,

246 > lockPriority,

247 > )

248 >

249 > metrics.ContextCounterAdd(ctx, metrics.HistoryWorkflowExecutionCacheLatency.Name(),

250 > time.Since(start).Nanoseconds())

251 >

252 > return weCtx, weReleaseFunc, err

253 }

254

262 forceClearContext bool,

263 lockPriority locks.Priority,

264 > ) (historyi.WorkflowContext, historyi.ReleaseWorkflowContextFunc, error) { cache.go

265 >

266 > if !softassert.That(

267 > shardContext.GetLogger(),

268 > archetypeID != chasm.UnspecifiedArchetypeID,

269 > "Creating execution cache key with unspecified archetype ID",

270 > ) {

271 archetypeID = chasm.WorkflowArchetypeID

272 }

273

274 > cacheKey := Key{ cache.go

275 > WorkflowKey: definition.NewWorkflowKey(namespaceID.String(), execution.GetWorkflowId(), execution.GetRunId()),

276 > ArchetypeID: archetypeID,

277 > ShardUUID: shardContext.GetOwner(),

278 > }

279 > item, cacheHit := c.Get(cacheKey).(*cacheItem)

280 > var workflowCtx historyi.WorkflowContext

281 > if cacheHit {

282 workflowCtx = item.wfContext

283 > } else { cache.go

284 > metrics.CacheMissCounter.With(handler).Record(1) cache.go

285 > workflowCtx = workflow.NewContext(

286 > shardContext.GetConfig(),

287 > cacheKey.WorkflowKey,

288 > archetypeID,

289 > shardContext.GetLogger(),

290 > shardContext.GetThrottledLogger(),

291 > shardContext.GetMetricsHandler(),

292 > )

293 >

294 > var err error

295 > value := &cacheItem{shardId: shardContext.GetShardID(), wfContext: workflowCtx, finalizer: shardContext.GetFinalizer()}

296 > existing, err := c.PutIfNotExist(cacheKey, value)

297 > if err != nil {

298 metrics.CacheFailures.With(handler).Record(1)

299 return nil, nil, err

300 }

301 //nolint:revive

302 > workflowCtx = existing.(*cacheItem).wfContext cache.go

303 }

304

305 > if err := c.lockWorkflowExecution(ctx, workflowCtx, cacheKey, lockPriority); err != nil { cache.go

306 metrics.CacheFailures.With(handler).Record(1)

307 metrics.AcquireLockFailedCounter.With(handler).Record(1)

311 // TODO This will create a closure on every request.

312 // Consider revisiting this if it causes too much GC activity

313 > releaseFunc := c.makeReleaseFunc(cacheKey, shardContext, workflowCtx, forceClearContext, handler, time.Now()) cache.go

314 >

315 > return workflowCtx, releaseFunc, nil

316 }

317

321 cacheKey Key,

322 lockPriority locks.Priority,

323 > ) error { cache.go

324 > // skip if there is no deadline

325 > if deadline, ok := ctx.Deadline(); ok {

326 var cancel context.CancelFunc

327 if headers.GetCallerInfo(ctx).CallerType != headers.CallerTypeAPI {

340 }

341

342 > if err := workflowCtx.Lock(ctx, lockPriority); err != nil { cache.go

343 // ctx is done before lock can be acquired

344 c.Release(cacheKey)

345 return consts.ErrResourceExhaustedBusyWorkflow

346 }

347 > return nil cache.go

348 }

349

355 handler metrics.Handler,

356 acquireTime time.Time,

357 > ) func(error) { cache.go

358 >

359 > status := cacheNotReleased

360 > return func(err error) {

361 > if atomic.CompareAndSwapInt32(&status, cacheNotReleased, cacheReleased) {

362 > defer func() {

363 > metrics.HistoryWorkflowExecutionCacheLockHoldDuration.With(handler).Record(time.Since(acquireTime))

364 > }()

365 > if rec := recover(); rec != nil {

366 wfContext.Clear()

367 wfContext.Unlock()

368 c.Release(cacheKey)

369 panic(rec)

370 > } else { cache.go

371 > if err != nil || forceClearContext {

372 // TODO see issue #668, there are certain type or errors which can bypass the clear

373 wfContext.Clear()

374 wfContext.Unlock()

375 c.Release(cacheKey)

376 > } else { cache.go

377 > isDirty := wfContext.IsDirty() cache.go

378 > if isDirty {

379 wfContext.Clear()

380 softassert.Fail(shardContext.GetLogger(), "Cache encountered dirty mutable state transaction",

385 )

386 }

387 > wfContext.Unlock() cache.go

388 > c.Release(cacheKey)

389 > if isDirty {

390 panic("Cache encountered dirty mutable state transaction")

391 }

403 archetypeID chasm.ArchetypeID,

404 lockPriority locks.Priority,

405 > ) error { cache.go

406 >

407 > if err := c.validateWorkflowID(execution.GetWorkflowId()); err != nil {

408 return err

409 }

410

411 // RunID is not provided, lets try to retrieve the RunID for current active execution

412 > if execution.GetRunId() == "" { cache.go

413 runID, err := GetCurrentRunID(

414 ctx,

425

426 execution.RunId = runID

427 > } else if uuid.Validate(execution.GetRunId()) != nil { // immediately return if invalid runID cache.go

428 return serviceerror.NewInvalidArgument("RunId is not valid UUID.")

429 }

430 > return nil cache.go

431 }

432

433 func (c *cacheImpl) validateWorkflowID(

434 workflowID string,

435 > ) error { cache.go

436 > if workflowID == "" {

437 return serviceerror.NewInvalidArgument("Can't load workflow execution. WorkflowId not set.")

438 }

439 > return nil cache.go

440 }

441

477 }

478

479 > func (c *cacheItem) CacheSize() int { cache.go

480 > if sg, ok := c.wfContext.(cache.SizeGetter); ok {

481 > return sg.CacheSize() cache.go

482 > }

483 return 0

484 }

go.temporal.io/server/common/cache/lru.go 120 covered LOC · 35 ranges

Open complete file

126 }

127

128 > func (entry *entryImpl) Size() int { lru.go

129 > return entry.size

130 > }

131

132 func (entry *entryImpl) CreateTime() time.Time {

135

136 // New creates a new cache with the given options

137 > func New(maxSize int, opts *Options) StoppableCache { lru.go

138 > return NewWithMetrics(maxSize, opts, metrics.NoopMetricsHandler)

139 > }

140

141 // NewWithMetrics creates a new cache that will emit capacity and ttl metrics.

142 // handler should be tagged with metrics.CacheTypeTag.

143 > func NewWithMetrics(maxSize int, opts *Options, handler metrics.Handler) StoppableCache { lru.go

144 > if opts == nil {

145 opts = &Options{}

146 }

147

148 > backgroundEvict := opts.BackgroundEvict lru.go

149 > if backgroundEvict == nil {

150 > backgroundEvict = func() dynamicconfig.CacheBackgroundEvictSettings { lru.go

151 > return dynamicconfig.CacheBackgroundEvictSettings{

152 > Enabled: false,

153 > }

154 > }

155 }

156

157 > timeSource := opts.TimeSource lru.go

158 > if timeSource == nil {

159 > timeSource = clock.NewRealTimeSource() lru.go

160 > }

161

162 > metrics.CacheSize.With(handler).Record(float64(maxSize)) lru.go

163 > metrics.CacheTtl.With(handler).Record(opts.TTL)

164 > c := &lru{

165 > byAccess: list.New(),

166 > byKey: make(map[any]*list.Element),

167 > ttl: opts.TTL,

168 > maxSize: maxSize,

169 > currSize: 0,

170 > pin: opts.Pin,

171 > onPut: opts.OnPut,

172 > onEvict: opts.OnEvict,

173 > timeSource: timeSource,

174 > metricsHandler: handler,

175 > backgroundEvict: backgroundEvict,

176 > }

177 > if c.backgroundEvict().Enabled {

178 c.loops.Go(c.bgEvictLoop)

179 }

180 > return c lru.go

181 }

182

188

189 // Get retrieves the value stored under the given key

190 > func (c *lru) Get(key any) any { lru.go

191 > if c.maxSize == 0 { //

192 return nil

193 }

194 > c.mut.Lock() lru.go

195 > defer c.mut.Unlock()

196 >

197 > element := c.byKey[key]

198 > if element == nil {

199 > return nil lru.go

200 > }

201

202 entry := element.Value.(*entryImpl)

225

226 // PutIfNotExist puts a value associated with a given key if it does not exist

227 > func (c *lru) PutIfNotExist(key any, value any) (any, error) { lru.go

228 > existing, err := c.putInternal(key, value, false)

229 > if err != nil {

230 return nil, err

231 }

232

233 > if existing == nil { lru.go

234 > // This is a new value lru.go

235 > return value, err

236 > }

237

238 return existing, err

254

255 // Release decrements the ref count of a pinned element.

256 > func (c *lru) Release(key any) { lru.go

257 > if c.maxSize == 0 || !c.pin {

258 return

259 }

260 > c.mut.Lock() lru.go

261 > defer c.mut.Unlock()

262 >

263 > elt, ok := c.byKey[key]

264 > if !ok {

265 return

266 }

267 > entry := elt.Value.(*entryImpl) lru.go

268 > entry.refCount--

269 > if entry.refCount == 0 {

270 > c.pinnedSize -= entry.Size() lru.go

271 > metrics.CachePinnedUsage.With(c.metricsHandler).Record(float64(c.pinnedSize))

272 > }

273 // Entry size might have changed. Recalculate size and evict entries if necessary.

274 > newEntrySize := getSize(entry.value) lru.go

275 > c.currSize = c.calculateNewCacheSize(newEntrySize, entry.Size())

276 > entry.size = newEntrySize

277 > if c.currSize > c.maxSize {

278 c.tryEvictUntilCacheSizeUnderLimit()

279 }

280 > metrics.CacheUsage.With(c.metricsHandler).Record(float64(c.currSize)) lru.go

281 }

282

294 // Put puts a new value associated with a given key, returning the existing value (if present)

295 // allowUpdate flag is used to control overwrite behavior if the value exists.

296 > func (c *lru) putInternal(key any, value any, allowUpdate bool) (any, error) { lru.go

297 > if c.maxSize == 0 {

298 return nil, nil

299 }

300 > newEntrySize := getSize(value) lru.go

301 > if newEntrySize > c.maxSize {

302 return nil, ErrCacheItemTooLarge

303 }

304

305 > c.mut.Lock() lru.go

306 > defer c.mut.Unlock()

307 >

308 > elt := c.byKey[key]

309 > // If the entry exists, check if it has expired or update the value

310 > if elt != nil {

311 existingEntry := elt.Value.(*entryImpl)

312 if !c.isEntryExpired(existingEntry, c.timeSource.Now().UTC()) {

347 }

348

349 > c.tryEvictUntilEnoughSpaceWithSkipEntry(newEntrySize, nil) lru.go

350 >

351 > // check if the new entry can fit in the cache

352 > newCacheSize := c.calculateNewCacheSize(newEntrySize, emptyEntrySize)

353 > if newCacheSize > c.maxSize {

354 return nil, ErrCacheFull

355 }

356

357 > entry := &entryImpl{ lru.go

358 > key: key,

359 > value: value,

360 > size: newEntrySize,

361 > }

362 > c.updateEntryTTL(entry)

363 > c.updateEntryRefCount(entry)

364 > element := c.byAccess.PushFront(entry)

365 > c.byKey[key] = element

366 > c.currSize = newCacheSize

367 > metrics.CacheUsage.With(c.metricsHandler).Record(float64(c.currSize))

368 >

369 > if c.onPut != nil {

370 > c.onPut(value) lru.go

371 > }

372

373 > return nil, nil lru.go

374 }

375

376 > func (c *lru) calculateNewCacheSize(newEntrySize int, existingEntrySize int) int { lru.go

377 > return c.currSize - existingEntrySize + newEntrySize

378 > }

379

380 func (c *lru) deleteInternal(element *list.Element) {

397 // tryEvictUntilEnoughSpaceWithSkipEntry try to evict entries until there is enough space for the new entry without

398 // evicting the existing entry. the existing entry is skipped because it is being updated.

399 > func (c *lru) tryEvictUntilEnoughSpaceWithSkipEntry(newEntrySize int, existingEntry *entryImpl) { lru.go

400 > element := c.byAccess.Back()

401 > existingEntrySize := 0

402 > if existingEntry != nil {

403 existingEntrySize = existingEntry.Size()

404 }

405

406 > for c.calculateNewCacheSize(newEntrySize, existingEntrySize) > c.maxSize && element != nil { lru.go

407 entry := element.Value.(*entryImpl)

408 if existingEntry != nil && entry.key == existingEntry.key {

430 }

431

432 > func (c *lru) updateEntryTTL(entry *entryImpl) { lru.go

433 > if c.ttl != 0 {

434 > entry.createTime = c.timeSource.Now().UTC() lru.go

435 > }

436 }

437

438 > func (c *lru) updateEntryRefCount(entry *entryImpl) { lru.go

439 > if c.pin {

440 > entry.refCount++ lru.go

441 > if entry.refCount == 1 {

442 > c.pinnedSize += entry.Size()

443 > metrics.CachePinnedUsage.With(c.metricsHandler).Record(float64(c.pinnedSize))

444 > }

445 }

446 }

go.temporal.io/server/common/log/zap_logger.go 106 covered LOC · 28 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

130 > func (l *zapLogger) Debug(msg string, tags ...tag.Tag) { zap_logger.go

131 > if l.zl.Core().Enabled(zap.DebugLevel) {

132 msg = setDefaultMsg(msg)

133 fields := l.buildFieldsWithCallAt(tags)

136 }

137

138 > func (l *zapLogger) Info(msg string, tags ...tag.Tag) { zap_logger.go

139 > if l.zl.Core().Enabled(zap.InfoLevel) {

140 > msg = setDefaultMsg(msg)

141 > fields := l.buildFieldsWithCallAt(tags)

142 > l.zl.Info(msg, fields...)

143 > }

144 }

145

191 //

192 // by deduping "foo" against any existing "foo" tags *only in the former*

193 > func (l *zapLogger) With(tags ...tag.Tag) Logger { zap_logger.go

194 > cloneTags := mergeTags(l.tags, tags)

195 > if l.baseZl == nil {

196 l.baseZl = l.zl

197 }

198 > return l.cloneWithTags(cloneTags) zap_logger.go

199 }

200

201 > func (l *zapLogger) cloneWithTags(tags []tag.Tag) Logger { zap_logger.go

202 > fields := make([]zap.Field, len(tags))

203 > l.fillFields(tags, fields)

204 > zl := l.baseZl.With(fields...)

205 > return &zapLogger{

206 > zl: zl,

207 > skip: l.skip,

208 > baseZl: l.baseZl,

209 > tags: tags,

210 > }

211 > }

212

213 func (l *zapLogger) Skip(extraSkip int) Logger {

219 }

220

221 > func mergeTags(oldTags, newTags []tag.Tag) (outTags []tag.Tag) { zap_logger.go

222 > // Even if oldTags empty, we don't just return newTags because we need to de-dupe it.

223 > outTags = slices.Clone(oldTags)

224 > for _, t := range newTags {

225 > if i := slices.IndexFunc(outTags, func(ti tag.Tag) bool {

226 return ti.Key() == t.Key()

227 }); i >= 0 {

228 outTags[i] = t

229 > } else { zap_logger.go

230 > outTags = append(outTags, t)

231 > }

232 }

233 > return outTags zap_logger.go

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/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

190 // SetEngineForTest sets s.engine. Only used by tests.

191 > func (s *ContextTest) SetEngineForTesting(engine historyi.Engine) { context_testutil.go

192 > s.engineFuture.Set(engine, nil)

193 > }

194

195 // SetEventsCacheForTesting sets s.eventsCache. Only used by tests.

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/ndc/hsm_state_replicator.go 87 covered LOC · 24 ranges

Open complete file

46 workflowCache wcache.Cache,

47 logger log.Logger,

48 > ) *HSMStateReplicatorImpl { hsm_state_replicator.go

49 >

50 > return &HSMStateReplicatorImpl{

51 > shardContext: shardContext,

52 > workflowCache: workflowCache,

53 > logger: log.With(logger, tag.ComponentHSMStateReplicator),

54 > }

55 > }

56

57 func (r *HSMStateReplicatorImpl) SyncHSMState(

58 ctx context.Context,

59 request *historyi.SyncHSMRequest,

60 > ) (retError error) { hsm_state_replicator.go

61 > namespaceID := namespace.ID(request.GetNamespaceID())

62 > execution := &commonpb.WorkflowExecution{

63 > WorkflowId: request.GetWorkflowID(),

64 > RunId: request.GetRunID(),

65 > }

66 >

67 > lastItem, err := versionhistory.GetLastVersionHistoryItem(request.EventVersionHistory)

68 > if err != nil {

69 return err

70 }

71

72 > workflowContext, release, err := r.workflowCache.GetOrCreateWorkflowExecution( hsm_state_replicator.go

73 > ctx,

74 > r.shardContext,

75 > namespaceID,

76 > execution,

77 > locks.PriorityHigh,

78 > )

79 > if err != nil {

80 return err

81 }

82 > defer func() { release(retError) }() hsm_state_replicator.go

83

84 > mutableState, err := workflowContext.LoadMutableState(ctx, r.shardContext) hsm_state_replicator.go

85 > if err != nil {

86 if _, isNotFound := err.(*serviceerror.NotFound); isNotFound {

87 return serviceerrors.NewRetryReplication(

99 }

100

101 > synced, err := r.syncHSMNode(mutableState, request) hsm_state_replicator.go

102 > if err != nil {

103 return err

104 }

105 > if !synced { hsm_state_replicator.go

106 return consts.ErrDuplicate

107 }

108

109 > if r.shardContext.GetConfig().EnableUpdateWorkflowModeIgnoreCurrent() { hsm_state_replicator.go

110 > return workflowContext.UpdateWorkflowExecutionAsPassive(ctx, r.shardContext)

111 > }

112

113 // TODO: remove following code once EnableUpdateWorkflowModeIgnoreCurrent config is deprecated.

140 mutableState historyi.MutableState,

141 request *historyi.SyncHSMRequest,

142 > ) (bool, error) { hsm_state_replicator.go

143 >

144 > shouldSync, err := r.compareVersionHistory(mutableState, request.EventVersionHistory)

145 > if err != nil || !shouldSync {

146 return shouldSync, err

147 }

148

149 > currentHSM := mutableState.HSM() hsm_state_replicator.go

150 >

151 > // we don't care about the root here which is the entire mutable state

152 > incomingHSM, err := hsm.NewRoot(

153 > r.shardContext.StateMachineRegistry(),

154 > workflow.StateMachineType,

155 > mutableState,

156 > request.StateMachineNode.Children,

157 > mutableState,

158 > )

159 > if err != nil {

160 return false, err

161 }

162

163 > synced := false hsm_state_replicator.go

164 > if err := incomingHSM.Walk(func(incomingNode *hsm.Node) error {

165 >

166 > if incomingNode.Parent == nil {

167 > // skip root which is the entire mutable state

168 > return nil

169 > }

170

171 > incomingNodePath := incomingNode.Path() hsm_state_replicator.go

172 > currentNode, err := currentHSM.Child(incomingNodePath)

173 > if err != nil {

174 // The node may not be found if the state machine was deleted in terminal a state and this cluster is

175 // syncing from an older cluster that doesn't delete the state machine on completion.

182 }

183

184 > if shouldSyncNode, err := r.shouldSyncNode(currentNode, incomingNode); err != nil || !shouldSyncNode { hsm_state_replicator.go

185 if err != nil && errors.Is(err, hsm.ErrInitialTransitionMismatch) {

186 return nil

189 }

190

191 > synced = true hsm_state_replicator.go

192 > return currentNode.Sync(incomingNode)

193 }); err != nil {

194 return false, err

195 }

196

197 > return synced, nil hsm_state_replicator.go

198 }

199

200 func (r *HSMStateReplicatorImpl) shouldSyncNode(

201 currentNode, incomingNode *hsm.Node,

202 > ) (bool, error) { hsm_state_replicator.go

203 > currentLastUpdated := currentNode.InternalRepr().LastUpdateVersionedTransition

204 > incomingLastUpdated := incomingNode.InternalRepr().LastUpdateVersionedTransition

205 >

206 > if currentLastUpdated.TransitionCount != 0 && incomingLastUpdated.TransitionCount != 0 {

207 > return transitionhistory.Compare(currentLastUpdated, incomingLastUpdated) < 0, nil hsm_state_replicator.go

208 > }

209

210 if currentLastUpdated.NamespaceFailoverVersion == incomingLastUpdated.NamespaceFailoverVersion {

219 mutableState historyi.MutableState,

220 incomingVersionHistory *historyspb.VersionHistory,

221 > ) (bool, error) { hsm_state_replicator.go

222 > currentVersionHistory, err := versionhistory.GetCurrentVersionHistory(

223 > mutableState.GetExecutionInfo().GetVersionHistories(),

224 > )

225 > if err != nil {

226 return false, err

227 }

228

229 > lastLocalItem, err := versionhistory.GetLastVersionHistoryItem(currentVersionHistory) hsm_state_replicator.go

230 > if err != nil {

231 return false, err

232 }

233

234 > lastIncomingItem, err := versionhistory.GetLastVersionHistoryItem(incomingVersionHistory) hsm_state_replicator.go

235 > if err != nil {

236 return false, err

237 }

238

239 > lcaItem, err := versionhistory.FindLCAVersionHistoryItem(currentVersionHistory, incomingVersionHistory) hsm_state_replicator.go

240 > if err != nil {

241 return false, err

242 }

243

244 > if versionhistory.IsLCAVersionHistoryItemAppendable(currentVersionHistory, lcaItem) || hsm_state_replicator.go

245 > versionhistory.IsLCAVersionHistoryItemAppendable(incomingVersionHistory, lcaItem) {

246 > // not diverged, resend any missing events hsm_state_replicator.go

247 > if versionhistory.CompareVersionHistoryItem(lastLocalItem, lastIncomingItem) >= 0 {

248 > return true, nil hsm_state_replicator.go

249 > }

250

251 workflowKey := mutableState.GetWorkflowKey()

go.temporal.io/server/api/persistence/v1/hsm.pb.go 86 covered LOC · 23 ranges

Open complete file

71 func (*StateMachineNode) ProtoMessage() {}

72

73 > func (x *StateMachineNode) ProtoReflect() protoreflect.Message { hsm.pb.go

74 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[0]

75 > if x != nil {

76 > ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) hsm.pb.go

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

78 > ms.StoreMessageInfo(mi)

79 > }

80 > return ms

81 }

82 > return mi.MessageOf(x) hsm.pb.go

83 }

84

102 }

103

104 > func (x *StateMachineNode) GetInitialVersionedTransition() *VersionedTransition { hsm.pb.go

105 > if x != nil {

106 > return x.InitialVersionedTransition

107 > }

108 return nil

109 }

110

111 > func (x *StateMachineNode) GetLastUpdateVersionedTransition() *VersionedTransition { hsm.pb.go

112 > if x != nil {

113 > return x.LastUpdateVersionedTransition

114 > }

115 return nil

116 }

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

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

154 > ms.StoreMessageInfo(mi)

155 > }

156 > return ms

157 }

158 > return mi.MessageOf(x) hsm.pb.go

159 }

160

272 func (*StateMachineRef) ProtoMessage() {}

273

274 > func (x *StateMachineRef) ProtoReflect() protoreflect.Message { hsm.pb.go

275 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[3]

276 > if x != nil {

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

278 if ms.LoadMessageInfo() == nil {

281 return ms

282 }

283 > return mi.MessageOf(x) hsm.pb.go

284 }

285

349 func (*StateMachineTaskInfo) ProtoMessage() {}

350

351 > func (x *StateMachineTaskInfo) ProtoReflect() protoreflect.Message { hsm.pb.go

352 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[4]

353 > if x != nil {

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

355 if ms.LoadMessageInfo() == nil {

358 return ms

359 }

360 > return mi.MessageOf(x) hsm.pb.go

361 }

362

416 func (*StateMachineTimerGroup) ProtoMessage() {}

417

418 > func (x *StateMachineTimerGroup) ProtoReflect() protoreflect.Message { hsm.pb.go

419 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[5]

420 > if x != nil {

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

422 if ms.LoadMessageInfo() == nil {

425 return ms

426 }

427 > return mi.MessageOf(x) hsm.pb.go

428 }

429

478 func (*VersionedTransition) ProtoMessage() {}

479

480 > func (x *VersionedTransition) ProtoReflect() protoreflect.Message { hsm.pb.go

481 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[6]

482 > if x != nil {

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

484 if ms.LoadMessageInfo() == nil {

487 return ms

488 }

489 > return mi.MessageOf(x) hsm.pb.go

490 }

491

495 }

496

497 > func (x *VersionedTransition) GetNamespaceFailoverVersion() int64 { hsm.pb.go

498 > if x != nil {

499 > return x.NamespaceFailoverVersion hsm.pb.go

500 > }

501 return 0

502 }

503

504 > func (x *VersionedTransition) GetTransitionCount() int64 { hsm.pb.go

505 > if x != nil {

506 > return x.TransitionCount hsm.pb.go

507 > }

508 return 0

509 }

531 func (*StateMachineTombstoneBatch) ProtoMessage() {}

532

533 > func (x *StateMachineTombstoneBatch) ProtoReflect() protoreflect.Message { hsm.pb.go

534 > mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[7]

535 > if x != nil {

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

537 if ms.LoadMessageInfo() == nil {

540 return ms

541 }

542 > return mi.MessageOf(x) hsm.pb.go

543 }

544

895 }

896

897 > func init() { file_temporal_server_api_persistence_v1_hsm_proto_init() } hsm.pb.go

898 > func file_temporal_server_api_persistence_v1_hsm_proto_init() {

899 > if File_temporal_server_api_persistence_v1_hsm_proto != nil {

900 > return

901 > }

902 > file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[8].OneofWrappers = []any{

903 > (*StateMachineTombstone_ActivityScheduledEventId)(nil),

904 > (*StateMachineTombstone_TimerId)(nil),

905 > (*StateMachineTombstone_ChildExecutionInitiatedEventId)(nil),

906 > (*StateMachineTombstone_RequestCancelInitiatedEventId)(nil),

907 > (*StateMachineTombstone_SignalExternalInitiatedEventId)(nil),

908 > (*StateMachineTombstone_UpdateId)(nil),

909 > (*StateMachineTombstone_StateMachinePath)(nil),

910 > (*StateMachineTombstone_ChasmNodePath)(nil),

911 > }

912 > type x struct{}

913 > out := protoimpl.TypeBuilder{

914 > File: protoimpl.DescBuilder{

915 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

916 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_hsm_proto_rawDesc), len(file_temporal_server_api_persistence_v1_hsm_proto_rawDesc)),

917 > NumEnums: 0,

918 > NumMessages: 12,

919 > NumExtensions: 0,

920 > NumServices: 0,

921 > },

922 > GoTypes: file_temporal_server_api_persistence_v1_hsm_proto_goTypes,

923 > DependencyIndexes: file_temporal_server_api_persistence_v1_hsm_proto_depIdxs,

924 > MessageInfos: file_temporal_server_api_persistence_v1_hsm_proto_msgTypes,

925 > }.Build()

926 > File_temporal_server_api_persistence_v1_hsm_proto = out.File

927 > file_temporal_server_api_persistence_v1_hsm_proto_goTypes = nil

928 > file_temporal_server_api_persistence_v1_hsm_proto_depIdxs = nil

929 }

go.temporal.io/server/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/service/history/workflow/task_generator.go 79 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(

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

306 case hsm.DeleteOperation:

307 deleteStateMachineTimersByPath(r.mutableState.GetExecutionInfo(), transitionOp.Path())

308 > case hsm.TransitionOperation: task_generator.go

309 > node, err := tree.Child(transitionOp.Path())

310 > if err != nil {

311 return err

312 }

313 > for _, task := range transitionOp.Output.Tasks { task_generator.go

314 > // since this method is called after transition history is updated for the current transition,

315 > // we can safely call generateSubStateMachineTask which sets MutableStateVersionedTransition

316 > // to the last versioned transition in StateMachineRef

317 > if err := generateSubStateMachineTask(

318 > r.mutableState,

319 > stateMachineRegistry,

320 > node,

321 > transitionOp.Path(),

322 > transitionOp.Output.TransitionCount,

323 > task,

324 > ); err != nil {

325 return err

326 }

329 }

330

331 > AddNextStateMachineTimerTask(r.mutableState) task_generator.go

332 >

333 > return nil

334 }

335

935 transitionCount int64,

936 task hsm.Task,

937 > ) error { task_generator.go

938 > ser, ok := stateMachineRegistry.TaskSerializer(task.Type())

939 > if !ok {

940 return serviceerror.NewInternalf("no task serializer for %v", task.Type())

941 }

942 > data, err := ser.Serialize(task) task_generator.go

943 > if err != nil {

944 return err

945 }

946 > ppath := make([]*persistencespb.StateMachineKey, len(subStateMachinePath)) task_generator.go

947 > for i, k := range subStateMachinePath {

948 > ppath[i] = &persistencespb.StateMachineKey{

949 > Type: k.Type,

950 > Id: k.ID,

951 > }

952 > }

953 > machineLastUpdateVersionedTransition := node.InternalRepr().GetLastUpdateVersionedTransition()

954 >

955 > currentVersionedTransition := mutableState.CurrentVersionedTransition()

956 > ref := &persistencespb.StateMachineRef{

957 > Path: ppath,

958 > MutableStateVersionedTransition: currentVersionedTransition,

959 > MachineInitialVersionedTransition: node.InternalRepr().GetInitialVersionedTransition(),

960 > MachineLastUpdateVersionedTransition: machineLastUpdateVersionedTransition,

961 > MachineTransitionCount: transitionCount,

962 > }

963 >

964 > // Task is invalid at generation time.

965 > // This may happen during replication when multiple event batches are applied in a single transaction.

966 > if err := task.Validate(ref, node); err != nil {

967 return nil

968 }

969

970 > taskInfo := &persistencespb.StateMachineTaskInfo{ task_generator.go

971 > Ref: ref,

972 > Type: task.Type(),

973 > Data: data,

974 > }

975 > // NOTE: at the moment deadline is mutually exclusive with destination.

976 > // This will change when we add the outbound timer queue.

977 > if task.Deadline() != hsm.Immediate {

978 > if task.Destination() != "" { task_generator.go

979 // TODO: support outbound timer tasks.

980 return fmt.Errorf("task cannot have both a deadline and destination due to missing outbound timer queue implementation")

981 }

982 > TrackStateMachineTimer(mutableState, task.Deadline(), taskInfo) task_generator.go

983 > } else if task.Destination() != "" { task_generator.go

984 > mutableState.AddTasks(&tasks.StateMachineOutboundTask{

985 > StateMachineTask: tasks.StateMachineTask{

986 > WorkflowKey: mutableState.GetWorkflowKey(),

987 > Info: taskInfo,

988 > },

989 > Destination: task.Destination(),

990 > })

991 > } else {

992 // TODO: support "transfer" tasks - immediate without destination.

993 return fmt.Errorf("task has no deadline or destination")

994 }

995

996 > return nil task_generator.go

997 }

998

go.temporal.io/server/service/history/shard/task_key_generator.go 69 covered LOC · 14 ranges

Open complete file

39 logger log.Logger,

40 renewRangeIDFn renewRangeIDFn,

41 > ) *taskKeyGenerator { task_key_generator.go

42 > return &taskKeyGenerator{

43 > nextTaskID: taskIDUninitialized,

44 > exclusiveMaxTaskID: taskIDUninitialized,

45 > rangeSizeBits: rangeSizeBits,

46 > timeSource: timeSource,

47 > logger: logger,

48 > renewRangeIDFn: renewRangeIDFn,

49 > }

50 > }

51

52 func (a *taskKeyGenerator) setTaskKeys(

53 taskMaps ...map[tasks.Category][]tasks.Task,

54 > ) error { task_key_generator.go

55 > now := a.timeSource.Now()

56 > // TODO: Truncation here is just to make sure task scheduled time has the same precision as the old logic.

57 > // Remove this truncation once we validate the rest of the code can worker correctly with higher precision.

58 > a.setTaskMinScheduledTime(now.Truncate(common.ScheduledTaskMinPrecision))

59 >

60 > for _, taskMap := range taskMaps {

61 > for category, tasksByCategory := range taskMap {

62 > isScheduledTask := category.Type() == tasks.CategoryTypeScheduled task_key_generator.go

63 > for _, task := range tasksByCategory {

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

65 > if err != nil {

66 return err

67 }

68 > task.SetTaskID(id) task_key_generator.go

69 >

70 > taskScheduledTime := now

71 > if isScheduledTask {

72 > // Persistence might loss precision when saving to DB. task_key_generator.go

73 > // Make the task scheduled time to have the same precision as DB here,

74 > // so that if the comparsion in the next step passes, it's guaranteed

75 > // the task can be retrieved from DB by queue processor.

76 > taskScheduledTime = task.GetVisibilityTime().

77 > Add(common.ScheduledTaskMinPrecision).

78 > Truncate(common.ScheduledTaskMinPrecision)

79 >

80 > if taskScheduledTime.Before(a.taskMinScheduledTime) {

81 a.logger.Debug("New timer generated is less than min scheduled time",

82 tag.WorkflowNamespaceID(task.GetNamespaceID()),

94 }

95 }

96 > task.SetVisibilityTime(taskScheduledTime) task_key_generator.go

97 >

98 > a.logger.Debug("Assigning new task key",

99 > tag.WorkflowNamespaceID(task.GetNamespaceID()),

100 > tag.WorkflowID(task.GetWorkflowID()),

101 > tag.WorkflowRunID(task.GetRunID()),

102 > tag.TaskType(task.GetType()),

103 > tag.TaskID(id),

104 > tag.Timestamp(task.GetVisibilityTime()),

105 > tag.CursorTimestamp(a.taskMinScheduledTime),

106 > )

107 }

108 }

109 }

110

111 > return nil task_key_generator.go

112 }

113

114 func (a *taskKeyGenerator) peekTaskKey(

115 category tasks.Category,

116 > ) tasks.Key { task_key_generator.go

117 > switch category.Type() {

118 > case tasks.CategoryTypeImmediate: task_key_generator.go

119 > return tasks.NewImmediateKey(a.nextTaskID)

120 case tasks.CategoryTypeScheduled:

121 return tasks.NewKey(

149 }

150

151 > func (a *taskKeyGenerator) setRangeID(rangeID int64) { task_key_generator.go

152 > a.nextTaskID = rangeID << a.rangeSizeBits

153 > a.exclusiveMaxTaskID = (rangeID + 1) << a.rangeSizeBits

154 >

155 > a.logger.Info("Task key range updated",

156 > tag.Number(a.nextTaskID),

157 > tag.NextNumber(a.exclusiveMaxTaskID),

158 > )

159 > }

160

161 func (a *taskKeyGenerator) setTaskMinScheduledTime(

162 taskMinScheduledTime time.Time,

163 > ) { task_key_generator.go

164 > a.taskMinScheduledTime = util.MaxTime(a.taskMinScheduledTime, taskMinScheduledTime)

165 > }

166

167 > func (a *taskKeyGenerator) generateTaskID() (int64, error) { task_key_generator.go

168 > if a.nextTaskID == taskIDUninitialized {

169 a.logger.Panic("Range id is not initialized before generating task id")

170 }

171

172 > if a.nextTaskID == a.exclusiveMaxTaskID { task_key_generator.go

173 if err := a.renewRangeIDFn(); err != nil {

174 return taskIDUninitialized, err

180 }

181

182 > taskID := a.nextTaskID task_key_generator.go

183 > a.nextTaskID++

184 > return taskID, nil

185 }

go.temporal.io/server/service/history/historybuilder/event_store.go 66 covered LOC · 17 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

262 }

263

264 > taskIDCount := 0 event_store.go

265 > for i := range dbEventsBatches {

266 taskIDCount += len(dbEventsBatches[i])

267 }

268 > taskIDs, err := b.taskIDGenerator(taskIDCount) event_store.go

269 > if err != nil {

270 return err

271 }

272

273 > taskIDPointer := 0 event_store.go

274 > height := len(dbEventsBatches)

275 > for i := range height {

276 width := len(dbEventsBatches[i])

277 for j := range width {

280 }

281 }

282 > return nil event_store.go

283 }

284

289 }

290

291 > func (b *EventStore) assertNotSealed() { event_store.go

292 > if b.state == HistoryBuilderStateSealed {

293 panic("history builder is in sealed state")

294 }

go.temporal.io/server/common/persistence/data_interfaces_mock.go 59 covered LOC · 12 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.

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.

431

432 // GetWorkflowExecution mocks base method.

433 > func (m *MockExecutionManager) GetWorkflowExecution(ctx context.Context, request *GetWorkflowExecutionRequest) (*GetWorkflowExecutionResponse, error) { data_interfaces_mock.go

434 > m.ctrl.T.Helper()

435 > ret := m.ctrl.Call(m, "GetWorkflowExecution", ctx, request)

436 > ret0, _ := ret[0].(*GetWorkflowExecutionResponse)

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

438 > return ret0, ret1

439 > }

440

441 // GetWorkflowExecution indicates an expected call of GetWorkflowExecution.

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

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

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

445 > }

446

447 // IsReplicationDLQEmpty mocks base method.

608

609 // UpdateWorkflowExecution mocks base method.

610 > func (m *MockExecutionManager) UpdateWorkflowExecution(ctx context.Context, request *UpdateWorkflowExecutionRequest) (*UpdateWorkflowExecutionResponse, error) { data_interfaces_mock.go

611 > m.ctrl.T.Helper()

612 > ret := m.ctrl.Call(m, "UpdateWorkflowExecution", ctx, request)

613 > ret0, _ := ret[0].(*UpdateWorkflowExecutionResponse)

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

615 > return ret0, ret1

616 > }

617

618 // UpdateWorkflowExecution indicates an expected call of UpdateWorkflowExecution.

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

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

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

622 > }

623

624 // MockTaskManager is a mock of TaskManager interface.

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/shard/task_request_tracker.go 58 covered LOC · 16 ranges

Open complete file

24 )

25

26 > func newTaskRequestTracker(registry tasks.TaskCategoryRegistry) *taskRequestTracker { task_request_tracker.go

27 > outstandingTaskKeys := make(map[tasks.Category]map[tasks.Key]struct{})

28 > for _, category := range registry.GetCategories() {

29 > outstandingTaskKeys[category] = make(map[tasks.Key]struct{})

30 > }

31 > return &taskRequestTracker{

32 > pendingTaskKeys: outstandingTaskKeys,

33 > }

34 }

35

36 func (t *taskRequestTracker) track(

37 taskMaps ...map[tasks.Category][]tasks.Task,

38 > ) taskRequestCompletionFn { task_request_tracker.go

39 > minKeyByCategory := make(map[tasks.Category]tasks.Key)

40 > for _, taskMap := range taskMaps {

41 > for category, tasksPerCategory := range taskMap {

42 > minKey := tasks.MaximumKey task_request_tracker.go

43 > for _, task := range tasksPerCategory {

44 > if task.GetKey().CompareTo(minKey) < 0 {

45 > minKey = task.GetKey()

46 > }

47 }

48 > if minKey.CompareTo(tasks.MaximumKey) == 0 { task_request_tracker.go

49 continue

50 }

51

52 > if _, ok := minKeyByCategory[category]; !ok { task_request_tracker.go

53 > minKeyByCategory[category] = minKey

54 > } else {

55 minKeyByCategory[category] = tasks.MinKey(minKeyByCategory[category], minKey)

56 }

58 }

59

60 > t.Lock() task_request_tracker.go

61 > defer t.Unlock()

62 >

63 > t.inflightRequestCount++

64 >

65 > for category, minKey := range minKeyByCategory {

66 > t.pendingTaskKeys[category][minKey] = struct{}{} task_request_tracker.go

67 > }

68

69 > return func(writeErr error) { task_request_tracker.go

70 > t.Lock() task_request_tracker.go

71 > defer t.Unlock()

72 >

73 > // Task key is not pending only when we get a definitive result from persistence.

74 > // This result can be either a success or a error that guarantees the task with that key

75 > // will not be persisted.

76 > if writeErr == nil || !persistence.OperationPossiblySucceeded(writeErr) {

77 > // we can only remove the task from the pending task list if we are sure it was inserted task_request_tracker.go

78 > // or the insertion is guaranteed to have failed

79 > for category, minKey := range minKeyByCategory {

80 > delete(t.pendingTaskKeys[category], minKey) task_request_tracker.go

81 > }

82 }

83

84 // While task key might still be pending, the request is completed and no longer inflight

85 > t.inflightRequestCount-- task_request_tracker.go

86 > if t.inflightRequestCount == 0 {

87 > t.closeWaitChannelsLocked() task_request_tracker.go

88 > }

89 }

90 }

130 }

131

132 > func (t *taskRequestTracker) clear() { task_request_tracker.go

133 > t.Lock()

134 > defer t.Unlock()

135 >

136 > for category := range t.pendingTaskKeys {

137 > t.pendingTaskKeys[category] = make(map[tasks.Key]struct{})

138 > }

139 > t.inflightRequestCount = 0

140 > t.closeWaitChannelsLocked()

141 }

142

143 > func (t *taskRequestTracker) closeWaitChannelsLocked() { task_request_tracker.go

144 > for _, waitCh := range t.waitChannels {

145 close(waitCh)

146 }

147 > t.waitChannels = nil task_request_tracker.go

148 }

go.temporal.io/server/common/log/tag/tags.go 54 covered LOC · 18 ranges

Open complete file

58

59 // Timestamp returns tag for Timestamp

60 > func Timestamp(timestamp time.Time) ZapTag { tags.go

61 > return NewTimeTag("timestamp", timestamp)

62 > }

63

64 // RequestID returns tag for RequestID

70

71 // WorkflowAction returns tag for WorkflowAction

72 > func workflowAction(action string) ZapTag { tags.go

73 > return NewStringTag("wf-action", action)

74 > }

75

76 // WorkflowListFilterType returns tag for WorkflowListFilterType

77 > func workflowListFilterType(listFilterType string) ZapTag { tags.go

78 > return NewStringTag("wf-list-filter-type", listFilterType)

79 > }

80

81 // general

108 // WorkflowID returns tag for WorkflowID

109 // TODO: Rename to BusinessID.

110 > func WorkflowID(workflowID string) ZapTag { tags.go

111 > return NewStringTag(WorkflowIDKey, workflowID)

112 > }

113

114 // WorkflowType returns tag for WorkflowType

124 // WorkflowRunID returns tag for WorkflowRunID

125 // TODO: Rename to RunID

126 > func WorkflowRunID(runID string) ZapTag { tags.go

127 > return NewStringTag(WorkflowRunIDKey, runID)

128 > }

129

130 // WorkflowNewRunID returns tag for WorkflowNewRunID

187 // WorkflowNamespaceID returns tag for WorkflowNamespaceID

188 // TODO: Rename to NamespaceID

189 > func WorkflowNamespaceID(namespaceID string) ZapTag { tags.go

190 > return NewStringTag("wf-namespace-id", namespaceID)

191 > }

192

193 // WorkflowNamespace returns tag for WorkflowNamespace

376

377 // Component returns tag for Component

378 > func component(component string) ZapTag { tags.go

379 > return NewStringTag("component", component)

380 > }

381

382 // Lifecycle returns tag for Lifecycle

383 > func lifecycle(lifecycle string) ZapTag { tags.go

384 > return NewStringTag("lifecycle", lifecycle)

385 > }

386

387 // StoreOperation returns tag for StoreOperation

388 > func storeOperation(storeOperation string) ZapTag { tags.go

389 > return NewStringTag("store-operation", storeOperation)

390 > }

391

392 // OperationResult returns tag for OperationResult

393 > func operationResult(operationResult string) ZapTag { tags.go

394 > return NewStringTag("operation-result", operationResult)

395 > }

396

397 // ErrorType returns tag for ErrorType

401

402 // errorType returns tag for ErrorType given a string

403 > func errorType(errorType string) ZapTag { tags.go

404 > return NewStringTag("error-type", errorType)

405 > }

406

407 // Shardupdate returns tag for Shardupdate

408 > func shardupdate(shardupdate string) ZapTag { tags.go

409 > return NewStringTag("shard-update", shardupdate)

410 > }

411

412 // scope returns a tag for scope

413 // Pre-defined scope tags are in values.go.

414 > func scope(scope string) ZapTag { tags.go

415 > return NewStringTag("scope", scope)

416 > }

417

418 // general

489

490 // CursorTimestamp returns tag for CursorTimestamp

491 > func CursorTimestamp(timestamp time.Time) ZapTag { tags.go

492 > return NewTimeTag("cursor-timestamp", timestamp)

493 > }

494

495 // MetricScope returns tag for MetricScope

524

525 // Number returns tag for Number

526 > func Number(n int64) ZapTag { tags.go

527 > return NewInt64("number", n)

528 > }

529

530 // NextNumber returns tag for NextNumber

531 > func NextNumber(n int64) ZapTag { tags.go

532 > return NewInt64("next-number", n)

533 > }

534

535 // ServerName returns tag for ServerName

620

621 // TaskID returns tag for TaskID

622 > func TaskID(taskID int64) ZapTag { tags.go

623 > return NewInt64("queue-task-id", taskID)

624 > }

625

626 // TaskKey returns tag for TaskKey

634 }

635

636 > func TaskType(taskType enumsspb.TaskType) ZapTag { tags.go

637 > return NewStringTag("queue-task-type", taskType.String())

638 > }

639

640 func TaskCategoryID(taskCategoryID int) ZapTag {

go.temporal.io/server/service/history/workflow/metrics.go 51 covered LOC · 9 ranges

Open complete file

22 historySize int,

23 historyCount int,

24 > ) { metrics.go

25 > handler := metricsHandler.WithTags(metrics.NamespaceTag(namespace.String()))

26 > executionScope := handler.WithTags(metrics.OperationTag(metrics.ExecutionStatsScope))

27 > metrics.HistorySize.With(executionScope).Record(int64(historySize))

28 > metrics.HistoryCount.With(executionScope).Record(int64(historyCount))

29 >

30 > if state == enumsspb.WORKFLOW_EXECUTION_STATE_COMPLETED {

31 completionScope := handler.WithTags(metrics.OperationTag(metrics.WorkflowCompletionStatsScope))

32 metrics.HistorySize.With(completionScope).Record(int64(historySize))

40 archetypeID chasm.ArchetypeID,

41 stats *persistence.MutableStateStatistics,

42 > ) { metrics.go

43 > if stats == nil {

44 > return metrics.go

45 > }

46

47 > mutableStateMetricsHandler := metricsHandler metrics.go

48 > if archetypeTag, ok := getArchetypeMetricTag(chasmRegistry, archetypeID); ok {

49 > mutableStateMetricsHandler = mutableStateMetricsHandler.WithTags(archetypeTag)

50 > }

51

52 > batchHandler := mutableStateMetricsHandler.StartBatch("mutable_state_status") metrics.go

53 > defer batchHandler.Close()

54 > metrics.MutableStateSize.With(batchHandler).Record(int64(stats.TotalSize))

55 > metrics.ExecutionInfoSize.With(batchHandler).Record(int64(stats.ExecutionInfoSize))

56 > metrics.ExecutionStateSize.With(batchHandler).Record(int64(stats.ExecutionStateSize))

57 > metrics.ActivityInfoSize.With(batchHandler).Record(int64(stats.ActivityInfoSize))

58 > metrics.ActivityInfoCount.With(batchHandler).Record(int64(stats.ActivityInfoCount))

59 > metrics.TotalActivityCount.With(batchHandler).Record(stats.TotalActivityCount)

60 > metrics.TimerInfoSize.With(batchHandler).Record(int64(stats.TimerInfoSize))

61 > metrics.TimerInfoCount.With(batchHandler).Record(int64(stats.TimerInfoCount))

62 > metrics.TotalUserTimerCount.With(batchHandler).Record(stats.TotalUserTimerCount)

63 > metrics.ChildInfoSize.With(batchHandler).Record(int64(stats.ChildInfoSize))

64 > metrics.ChildInfoCount.With(batchHandler).Record(int64(stats.ChildInfoCount))

65 > metrics.TotalChildExecutionCount.With(batchHandler).Record(stats.TotalChildExecutionCount)

66 > metrics.RequestCancelInfoSize.With(batchHandler).Record(int64(stats.RequestCancelInfoSize))

67 > metrics.RequestCancelInfoCount.With(batchHandler).Record(int64(stats.RequestCancelInfoCount))

68 > metrics.TotalRequestCancelExternalCount.With(batchHandler).Record(stats.TotalRequestCancelExternalCount)

69 > metrics.SignalInfoSize.With(batchHandler).Record(int64(stats.SignalInfoSize))

70 > metrics.SignalInfoCount.With(batchHandler).Record(int64(stats.SignalInfoCount))

71 > metrics.TotalSignalExternalCount.With(batchHandler).Record(stats.TotalSignalExternalCount)

72 > metrics.SignalRequestIDSize.With(batchHandler).Record(int64(stats.SignalRequestIDSize))

73 > metrics.SignalRequestIDCount.With(batchHandler).Record(int64(stats.SignalRequestIDCount))

74 > metrics.TotalSignalCount.With(batchHandler).Record(stats.TotalSignalCount)

75 > metrics.BufferedEventsSize.With(batchHandler).Record(int64(stats.BufferedEventsSize))

76 > metrics.BufferedEventsCount.With(batchHandler).Record(int64(stats.BufferedEventsCount))

77 > metrics.ChasmTotalSize.With(batchHandler).Record(int64(stats.ChasmTotalSize))

78 >

79 > if stats.HistoryStatistics != nil {

80 > metrics.HistorySize.With(metricsHandler).Record(int64(stats.HistoryStatistics.SizeDiff)) metrics.go

81 > metrics.HistoryCount.With(metricsHandler).Record(int64(stats.HistoryStatistics.CountDiff))

82 > }

83

84 > for category, taskCount := range stats.TaskCountByCategory { metrics.go

85 metrics.TaskCount.With(batchHandler).Record(int64(taskCount), metrics.TaskCategoryTag(category))

86 }

90 chasmRegistry *chasm.Registry,

91 archetypeID chasm.ArchetypeID,

92 > ) (metrics.Tag, bool) { metrics.go

93 > switch archetypeID {

94 case chasm.UnspecifiedArchetypeID:

95 return metrics.ArchetypeTag(""), true

96 > case chasm.WorkflowArchetypeID: metrics.go

97 > return metrics.ArchetypeTag(chasm.WorkflowComponentName), true

98 }

99

go.temporal.io/server/api/history/v1/message.pb.go 48 covered LOC · 14 ranges

Open complete file

92 func (*VersionHistoryItem) ProtoMessage() {}

93

94 > func (x *VersionHistoryItem) ProtoReflect() protoreflect.Message { message.pb.go

95 > mi := &file_temporal_server_api_history_v1_message_proto_msgTypes[1]

96 > if x != nil {

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

98 if ms.LoadMessageInfo() == nil {

101 return ms

102 }

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

104 }

105

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

151 if ms.LoadMessageInfo() == nil {

154 return ms

155 }

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

157 }

158

162 }

163

164 > func (x *VersionHistory) GetBranchToken() []byte { message.pb.go

165 > if x != nil {

166 > return x.BranchToken

167 > }

168 return nil

169 }

198 func (*VersionHistories) ProtoMessage() {}

199

200 > func (x *VersionHistories) ProtoReflect() protoreflect.Message { message.pb.go

201 > mi := &file_temporal_server_api_history_v1_message_proto_msgTypes[3]

202 > if x != nil {

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

204 if ms.LoadMessageInfo() == nil {

207 return ms

208 }

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

210 }

211

215 }

216

217 > func (x *VersionHistories) GetCurrentVersionHistoryIndex() int32 { message.pb.go

218 > if x != nil {

219 > return x.CurrentVersionHistoryIndex

220 > }

221 return 0

222 }

498 }

499

500 > func init() { file_temporal_server_api_history_v1_message_proto_init() } message.pb.go

501 > func file_temporal_server_api_history_v1_message_proto_init() {

502 > if File_temporal_server_api_history_v1_message_proto != nil {

503 return

504 }

505 > type x struct{} message.pb.go

506 > out := protoimpl.TypeBuilder{

507 > File: protoimpl.DescBuilder{

508 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

509 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_history_v1_message_proto_rawDesc), len(file_temporal_server_api_history_v1_message_proto_rawDesc)),

510 > NumEnums: 0,

511 > NumMessages: 8,

512 > NumExtensions: 0,

513 > NumServices: 0,

514 > },

515 > GoTypes: file_temporal_server_api_history_v1_message_proto_goTypes,

516 > DependencyIndexes: file_temporal_server_api_history_v1_message_proto_depIdxs,

517 > MessageInfos: file_temporal_server_api_history_v1_message_proto_msgTypes,

518 > }.Build()

519 > File_temporal_server_api_history_v1_message_proto = out.File

520 > file_temporal_server_api_history_v1_message_proto_goTypes = nil

521 > file_temporal_server_api_history_v1_message_proto_depIdxs = nil

522 }

go.temporal.io/server/common/metrics/defs.go 47 covered LOC · 9 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 { defs.go

63 > return handler.Histogram(d.name, d.unit)

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/common/persistence/versionhistory/version_history.go 47 covered LOC · 16 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.

18 > func CopyVersionHistory(v *historyspb.VersionHistory) *historyspb.VersionHistory { version_history.go

19 > token := make([]byte, len(v.BranchToken))

20 > copy(token, v.BranchToken)

21 >

22 > items := CopyVersionHistoryItems(v.Items)

23 >

24 > return NewVersionHistory(token, items)

25 > }

26

27 > func CopyVersionHistoryItems(items []*historyspb.VersionHistoryItem) []*historyspb.VersionHistoryItem { version_history.go

28 > var result []*historyspb.VersionHistoryItem

29 > for _, item := range items {

30 > result = append(result, CopyVersionHistoryItem(item)) version_history.go

31 > }

32 > return result version_history.go

33 }

34

107

108 // FindLCAVersionHistoryItem returns the lowest common ancestor VersionHistoryItem.

109 > func FindLCAVersionHistoryItem(v *historyspb.VersionHistory, remote *historyspb.VersionHistory) (*historyspb.VersionHistoryItem, error) { version_history.go

110 > return FindLCAVersionHistoryItemFromItemSlice(v.Items, remote.Items)

111 > }

112

113 > func FindLCAVersionHistoryItemFromItemSlice(versionHistoryItemsA []*historyspb.VersionHistoryItem, versionHistoryItemsB []*historyspb.VersionHistoryItem) (*historyspb.VersionHistoryItem, error) { version_history.go

114 > aIndex := len(versionHistoryItemsA) - 1

115 > bIndex := len(versionHistoryItemsB) - 1

116 >

117 > for aIndex >= 0 && bIndex >= 0 {

118 > aVersionItem := versionHistoryItemsA[aIndex]

119 > bVersionItem := versionHistoryItemsB[bIndex]

120 >

121 > if aVersionItem.Version == bVersionItem.Version {

122 > if aVersionItem.GetEventId() > bVersionItem.GetEventId() { version_history.go

123 return CopyVersionHistoryItem(bVersionItem), nil

124 }

125 > return aVersionItem, nil version_history.go

126 } else if aVersionItem.Version > bVersionItem.Version {

127 aIndex--

195

196 // IsLCAVersionHistoryItemAppendable checks if a LCA VersionHistoryItem is appendable.

197 > func IsLCAVersionHistoryItemAppendable(v *historyspb.VersionHistory, lcaItem *historyspb.VersionHistoryItem) bool { version_history.go

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

199 panic("version history not initialized")

200 }

201 > if lcaItem == nil { version_history.go

202 panic("lcaItem is nil")

203 }

204

205 > return IsEqualVersionHistoryItem(v.Items[len(v.Items)-1], lcaItem) version_history.go

206 }

207

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/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/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/locks/priority_semaphore_impl.go 41 covered LOC · 11 ranges

Open complete file

67 // maximum combined weight for concurrent access, capable of handling multiple priority levels.

68 // Most of the logic is taken directly from golang's semaphore.Weighted.

69 > func NewPrioritySemaphore(n int) *PrioritySemaphoreImpl { priority_semaphore_impl.go

70 > waitLists := make([]*list.List, NumPriorities)

71 > for i := range waitLists {

72 > waitLists[i] = list.New()

73 > }

74 > return &PrioritySemaphoreImpl{

75 > size: n,

76 > waitLists: waitLists,

77 > }

78 }

79

81 // are available or ctx is done. On success, returns nil. On failure, returns

82 // ctx.Err() and leaves the semaphore unchanged.

83 > func (s *PrioritySemaphoreImpl) Acquire(ctx context.Context, priority Priority, n int) error { priority_semaphore_impl.go

84 > if priority >= NumPriorities {

85 // nolint:forbidigo

86 panic(fmt.Sprintf("semaphore: invalid priority %v, priority must be less than %v", priority, NumPriorities))

87 }

88

89 > done := ctx.Done() priority_semaphore_impl.go

90 >

91 > s.mu.Lock()

92 > select {

93 case <-done:

94 // ctx becoming done has "happened before" acquiring the semaphore,

98 s.mu.Unlock()

99 return ctx.Err()

100 > default: priority_semaphore_impl.go

101 }

102 // Check if acquisition can proceed without waiting

103 > if s.size-s.cur >= n && s.noWaiters(priority) { priority_semaphore_impl.go

104 > // Since we hold s.mu and haven't synchronized since checking done, if priority_semaphore_impl.go

105 > // ctx becomes done before we return here, it becoming done must have

106 > // "happened concurrently" with this call - it cannot "happen before"

107 > // we return in this branch. So, we're ok to always acquire here.

108 > s.cur += n

109 > s.mu.Unlock()

110 > return nil

111 > }

112

113 if n > s.size {

173 }

174

175 > func (s *PrioritySemaphoreImpl) Release(n int) { priority_semaphore_impl.go

176 > s.mu.Lock()

177 > defer s.mu.Unlock()

178 > s.cur -= n

179 > if s.cur < 0 {

180 s.mu.Unlock()

181 panic("semaphore: released more than held")

182 }

183 > s.notifyWaiters() priority_semaphore_impl.go

184 }

185

186 > func (s *PrioritySemaphoreImpl) notifyWaiters() { priority_semaphore_impl.go

187 > for _, l := range s.waitLists {

188 > for {

189 > next := l.Front()

190 > if next == nil {

191 > break // No more waiters blocked.

192 }

193

219

220 // noWaiters returns if there is no waiter that has priority higher or equal to lowestPriority.

221 > func (s *PrioritySemaphoreImpl) noWaiters(lowestPriority Priority) bool { priority_semaphore_impl.go

222 > for _, l := range s.waitLists[:lowestPriority+1] {

223 > if l.Len() > 0 {

224 return false

225 }

226 }

227 > return true priority_semaphore_impl.go

228 }

go.temporal.io/server/common/cluster/metadata_mock.go 40 covered LOC · 9 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.

64

65 // GetAllClusterInfo indicates an expected call of GetAllClusterInfo.

66 > func (mr *MockMetadataMockRecorder) GetAllClusterInfo() *gomock.Call { metadata_mock.go

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

68 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllClusterInfo", reflect.TypeOf((*MockMetadata)(nil).GetAllClusterInfo))

69 > }

70

71 // GetClusterID mocks base method.

72 > func (m *MockMetadata) GetClusterID() int64 { metadata_mock.go

73 > m.ctrl.T.Helper()

74 > ret := m.ctrl.Call(m, "GetClusterID")

75 > ret0, _ := ret[0].(int64)

76 > return ret0

77 > }

78

79 // GetClusterID indicates an expected call of GetClusterID.

80 > func (mr *MockMetadataMockRecorder) GetClusterID() *gomock.Call { metadata_mock.go

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

82 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterID", reflect.TypeOf((*MockMetadata)(nil).GetClusterID))

83 > }

84

85 // GetCurrentClusterName mocks base method.

92

93 // GetCurrentClusterName indicates an expected call of GetCurrentClusterName.

94 > func (mr *MockMetadataMockRecorder) GetCurrentClusterName() *gomock.Call { metadata_mock.go

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

96 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentClusterName", reflect.TypeOf((*MockMetadata)(nil).GetCurrentClusterName))

97 > }

98

99 // GetFailoverVersionIncrement mocks base method.

162

163 // IsGlobalNamespaceEnabled indicates an expected call of IsGlobalNamespaceEnabled.

164 > func (mr *MockMetadataMockRecorder) IsGlobalNamespaceEnabled() *gomock.Call { metadata_mock.go

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

166 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsGlobalNamespaceEnabled", reflect.TypeOf((*MockMetadata)(nil).IsGlobalNamespaceEnabled))

167 > }

168

169 // IsMasterCluster mocks base method.

182

183 // IsVersionFromSameCluster mocks base method.

184 > func (m *MockMetadata) IsVersionFromSameCluster(version1, version2 int64) bool { metadata_mock.go

185 > m.ctrl.T.Helper()

186 > ret := m.ctrl.Call(m, "IsVersionFromSameCluster", version1, version2)

187 > ret0, _ := ret[0].(bool)

188 > return ret0

189 > }

190

191 // IsVersionFromSameCluster indicates an expected call of IsVersionFromSameCluster.

192 > func (mr *MockMetadataMockRecorder) IsVersionFromSameCluster(version1, version2 any) *gomock.Call { metadata_mock.go

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

194 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsVersionFromSameCluster", reflect.TypeOf((*MockMetadata)(nil).IsVersionFromSameCluster), version1, version2)

195 > }

196

197 // RegisterMetadataChangeCallback mocks base method.

go.temporal.io/server/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/api/adminservice/v1/request_response.pb.go 36 covered LOC · 1 range

Open complete file

6623 }

6624

6625 > func init() { file_temporal_server_api_adminservice_v1_request_response_proto_init() } request_response.pb.go

6626 > func file_temporal_server_api_adminservice_v1_request_response_proto_init() {

6627 > if File_temporal_server_api_adminservice_v1_request_response_proto != nil {

6628 > return

6629 > }

6630 > file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[59].OneofWrappers = []any{

6631 > (*StreamWorkflowReplicationMessagesRequest_SyncReplicationState)(nil),

6632 > }

6633 > file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[60].OneofWrappers = []any{

6634 > (*StreamWorkflowReplicationMessagesResponse_Messages)(nil),

6635 > }

6636 > file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[61].OneofWrappers = []any{

6637 > (*GetNamespaceRequest_Namespace)(nil),

6638 > (*GetNamespaceRequest_Id)(nil),

6639 > }

6640 > file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes[90].OneofWrappers = []any{

6641 > (*StartAdminBatchOperationRequest_RefreshTasksOperation)(nil),

6642 > }

6643 > type x struct{}

6644 > out := protoimpl.TypeBuilder{

6645 > File: protoimpl.DescBuilder{

6646 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

6647 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_adminservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_adminservice_v1_request_response_proto_rawDesc)),

6648 > NumEnums: 1,

6649 > NumMessages: 105,

6650 > NumExtensions: 0,

6651 > NumServices: 0,

6652 > },

6653 > GoTypes: file_temporal_server_api_adminservice_v1_request_response_proto_goTypes,

6654 > DependencyIndexes: file_temporal_server_api_adminservice_v1_request_response_proto_depIdxs,

6655 > EnumInfos: file_temporal_server_api_adminservice_v1_request_response_proto_enumTypes,

6656 > MessageInfos: file_temporal_server_api_adminservice_v1_request_response_proto_msgTypes,

6657 > }.Build()

6658 > File_temporal_server_api_adminservice_v1_request_response_proto = out.File

6659 > file_temporal_server_api_adminservice_v1_request_response_proto_goTypes = nil

6660 > file_temporal_server_api_adminservice_v1_request_response_proto_depIdxs = nil

6661 }

go.temporal.io/server/api/replication/v1/message.pb.go 36 covered LOC · 2 ranges

Open complete file

2441 }

2442

2443 > func init() { file_temporal_server_api_replication_v1_message_proto_init() } message.pb.go

2444 > func file_temporal_server_api_replication_v1_message_proto_init() {

2445 > if File_temporal_server_api_replication_v1_message_proto != nil {

2446 return

2447 }

2448 > file_temporal_server_api_replication_v1_message_proto_msgTypes[0].OneofWrappers = []any{ message.pb.go

2449 > (*ReplicationTask_NamespaceTaskAttributes)(nil),

2450 > (*ReplicationTask_SyncShardStatusTaskAttributes)(nil),

2451 > (*ReplicationTask_SyncActivityTaskAttributes)(nil),

2452 > (*ReplicationTask_HistoryTaskAttributes)(nil),

2453 > (*ReplicationTask_SyncWorkflowStateTaskAttributes)(nil),

2454 > (*ReplicationTask_TaskQueueUserDataAttributes)(nil),

2455 > (*ReplicationTask_SyncHsmAttributes)(nil),

2456 > (*ReplicationTask_BackfillHistoryTaskAttributes)(nil),

2457 > (*ReplicationTask_VerifyVersionedTransitionTaskAttributes)(nil),

2458 > (*ReplicationTask_SyncVersionedTransitionTaskAttributes)(nil),

2459 > }

2460 > file_temporal_server_api_replication_v1_message_proto_msgTypes[21].OneofWrappers = []any{

2461 > (*VersionedTransitionArtifact_SyncWorkflowStateMutationAttributes)(nil),

2462 > (*VersionedTransitionArtifact_SyncWorkflowStateSnapshotAttributes)(nil),

2463 > }

2464 > type x struct{}

2465 > out := protoimpl.TypeBuilder{

2466 > File: protoimpl.DescBuilder{

2467 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

2468 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_replication_v1_message_proto_rawDesc), len(file_temporal_server_api_replication_v1_message_proto_rawDesc)),

2469 > NumEnums: 0,

2470 > NumMessages: 23,

2471 > NumExtensions: 0,

2472 > NumServices: 0,

2473 > },

2474 > GoTypes: file_temporal_server_api_replication_v1_message_proto_goTypes,

2475 > DependencyIndexes: file_temporal_server_api_replication_v1_message_proto_depIdxs,

2476 > MessageInfos: file_temporal_server_api_replication_v1_message_proto_msgTypes,

2477 > }.Build()

2478 > File_temporal_server_api_replication_v1_message_proto = out.File

2479 > file_temporal_server_api_replication_v1_message_proto_goTypes = nil

2480 > file_temporal_server_api_replication_v1_message_proto_depIdxs = nil

2481 }

go.temporal.io/server/common/namespace/testconstructors.go 36 covered LOC · 8 ranges

Open complete file

13 config *persistencespb.NamespaceConfig,

14 targetCluster string,

15 > ) *Namespace { testconstructors.go

16 > detail := &persistencespb.NamespaceDetail{

17 > Info: ensureInfo(info),

18 > Config: ensureConfig(config),

19 > ReplicationConfig: &persistencespb.NamespaceReplicationConfig{

20 > ActiveClusterName: targetCluster,

21 > Clusters: []string{targetCluster},

22 > },

23 > FailoverVersion: common.EmptyVersion,

24 > }

25 > factory := NewDefaultReplicationResolverFactory()

26 > resolver := factory(detail)

27 > ns, _ := FromPersistentState(detail, resolver, WithGlobalFlag(false))

28 > return ns

29 > }

30

31 // NewNamespaceForTest returns an entry with test data

55 repConfig *persistencespb.NamespaceReplicationConfig,

56 failoverVersion int64,

57 > ) *Namespace { testconstructors.go

58 > detail := &persistencespb.NamespaceDetail{

59 > Info: ensureInfo(info),

60 > Config: ensureConfig(config),

61 > ReplicationConfig: ensureRepConfig(repConfig),

62 > FailoverVersion: failoverVersion,

63 > }

64 > factory := NewDefaultReplicationResolverFactory()

65 > resolver := factory(detail)

66 > ns, _ := FromPersistentState(detail, resolver, WithGlobalFlag(true))

67 > return ns

68 > }

69

70 > func ensureInfo(proto *persistencespb.NamespaceInfo) *persistencespb.NamespaceInfo { testconstructors.go

71 > if proto == nil {

72 return &persistencespb.NamespaceInfo{}

73 }

74 > return proto testconstructors.go

75 }

76

77 > func ensureConfig(proto *persistencespb.NamespaceConfig) *persistencespb.NamespaceConfig { testconstructors.go

78 > if proto == nil {

79 return &persistencespb.NamespaceConfig{}

80 }

81 > return proto testconstructors.go

82 }

83

84 > func ensureRepConfig(proto *persistencespb.NamespaceReplicationConfig) *persistencespb.NamespaceReplicationConfig { testconstructors.go

85 > if proto == nil {

86 return &persistencespb.NamespaceReplicationConfig{}

87 }

88 > return proto testconstructors.go

89 }

go.temporal.io/server/service/history/tasks/state_machine_task.go 36 covered LOC · 12 ranges

Open complete file

23 }

24

25 > func (t *StateMachineTask) SetTaskID(id int64) { state_machine_task.go

26 > t.TaskID = id

27 > }

28

29 > func (t *StateMachineTask) GetVisibilityTime() time.Time { state_machine_task.go

30 > return t.VisibilityTimestamp

31 > }

32

33 > func (t *StateMachineTask) SetVisibilityTime(timestamp time.Time) { state_machine_task.go

34 > t.VisibilityTimestamp = timestamp

35 > }

36

37 func (t *StateMachineTask) OutboundTaskGroup() string {

50 }

51

52 > func (*StateMachineOutboundTask) GetCategory() Category { state_machine_task.go

53 > return CategoryOutbound

54 > }

55

56 > func (*StateMachineOutboundTask) GetType() enumsspb.TaskType { state_machine_task.go

57 > return enumsspb.TASK_TYPE_STATE_MACHINE_OUTBOUND

58 > }

59

60 > func (t *StateMachineOutboundTask) GetKey() Key { state_machine_task.go

61 > return NewImmediateKey(t.TaskID)

62 > }

63

64 var _ Task = &StateMachineOutboundTask{}

73 }

74

75 > func (*StateMachineTimerTask) GetCategory() Category { state_machine_task.go

76 > return CategoryTimer

77 > }

78

79 > func (*StateMachineTimerTask) GetType() enumsspb.TaskType { state_machine_task.go

80 > return enumsspb.TASK_TYPE_STATE_MACHINE_TIMER

81 > }

82

83 > func (t *StateMachineTimerTask) GetKey() Key { state_machine_task.go

84 > return NewKey(t.VisibilityTimestamp, t.TaskID)

85 > }

86

87 func (t *StateMachineTimerTask) GetTaskID() int64 {

89 }

90

91 > func (t *StateMachineTimerTask) SetTaskID(id int64) { state_machine_task.go

92 > t.TaskID = id

93 > }

94

95 > func (t *StateMachineTimerTask) GetVisibilityTime() time.Time { state_machine_task.go

96 > return t.VisibilityTimestamp

97 > }

98

99 > func (t *StateMachineTimerTask) SetVisibilityTime(timestamp time.Time) { state_machine_task.go

100 > t.VisibilityTimestamp = timestamp

101 > }

102

103 var _ Task = &StateMachineTimerTask{}

go.temporal.io/server/api/persistence/v1/update.pb.go 35 covered LOC · 3 ranges

Open complete file

222 func (*UpdateInfo) ProtoMessage() {}

223

224 > func (x *UpdateInfo) ProtoReflect() protoreflect.Message { update.pb.go

225 > mi := &file_temporal_server_api_persistence_v1_update_proto_msgTypes[3]

226 > if x != nil {

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

228 if ms.LoadMessageInfo() == nil {

231 return ms

232 }

233 > return mi.MessageOf(x) update.pb.go

234 }

235

422 }

423

424 > func init() { file_temporal_server_api_persistence_v1_update_proto_init() } update.pb.go

425 > func file_temporal_server_api_persistence_v1_update_proto_init() {

426 > if File_temporal_server_api_persistence_v1_update_proto != nil {

427 > return

428 > }

429 > file_temporal_server_api_persistence_v1_hsm_proto_init()

430 > file_temporal_server_api_persistence_v1_update_proto_msgTypes[0].OneofWrappers = []any{

431 > (*UpdateAdmissionInfo_HistoryPointer_)(nil),

432 > }

433 > file_temporal_server_api_persistence_v1_update_proto_msgTypes[3].OneofWrappers = []any{

434 > (*UpdateInfo_Acceptance)(nil),

435 > (*UpdateInfo_Completion)(nil),

436 > (*UpdateInfo_Admission)(nil),

437 > }

438 > type x struct{}

439 > out := protoimpl.TypeBuilder{

440 > File: protoimpl.DescBuilder{

441 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

442 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_update_proto_rawDesc), len(file_temporal_server_api_persistence_v1_update_proto_rawDesc)),

443 > NumEnums: 0,

444 > NumMessages: 5,

445 > NumExtensions: 0,

446 > NumServices: 0,

447 > },

448 > GoTypes: file_temporal_server_api_persistence_v1_update_proto_goTypes,

449 > DependencyIndexes: file_temporal_server_api_persistence_v1_update_proto_depIdxs,

450 > MessageInfos: file_temporal_server_api_persistence_v1_update_proto_msgTypes,

451 > }.Build()

452 > File_temporal_server_api_persistence_v1_update_proto = out.File

453 > file_temporal_server_api_persistence_v1_update_proto_goTypes = nil

454 > file_temporal_server_api_persistence_v1_update_proto_depIdxs = nil

455 }

go.temporal.io/server/common/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/api/enums/v1/task.pb.go 32 covered LOC · 7 ranges

Open complete file

217 }

218

219 > func (x TaskType) String() string { task.pb.go

220 > switch x {

221 case TASK_TYPE_UNSPECIFIED:

222 return "Unspecified"

275 case TASK_TYPE_ARCHIVAL_ARCHIVE_EXECUTION:

276 return "ArchivalArchiveExecution"

277 > case TASK_TYPE_STATE_MACHINE_OUTBOUND: task.pb.go

278 > return "StateMachineOutbound"

279 > case TASK_TYPE_STATE_MACHINE_TIMER: task.pb.go

280 > return "StateMachineTimer"

281 case TASK_TYPE_WORKFLOW_EXECUTION_TIMEOUT:

282 return "WorkflowExecutionTimeout"

303 }

304

305 > func (TaskType) Descriptor() protoreflect.EnumDescriptor { task.pb.go

306 > return file_temporal_server_api_enums_v1_task_proto_enumTypes[1].Descriptor()

307 > }

308

309 func (TaskType) Type() protoreflect.EnumType {

361 }

362

363 > func (TaskPriority) Descriptor() protoreflect.EnumDescriptor { task.pb.go

364 > return file_temporal_server_api_enums_v1_task_proto_enumTypes[2].Descriptor()

365 > }

366

367 func (TaskPriority) Type() protoreflect.EnumType {

456 }

457

458 > func init() { file_temporal_server_api_enums_v1_task_proto_init() } task.pb.go

459 > func file_temporal_server_api_enums_v1_task_proto_init() {

460 > if File_temporal_server_api_enums_v1_task_proto != nil {

461 return

462 }

463 > type x struct{} task.pb.go

464 > out := protoimpl.TypeBuilder{

465 > File: protoimpl.DescBuilder{

466 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

467 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_task_proto_rawDesc), len(file_temporal_server_api_enums_v1_task_proto_rawDesc)),

468 > NumEnums: 3,

469 > NumMessages: 0,

470 > NumExtensions: 0,

471 > NumServices: 0,

472 > },

473 > GoTypes: file_temporal_server_api_enums_v1_task_proto_goTypes,

474 > DependencyIndexes: file_temporal_server_api_enums_v1_task_proto_depIdxs,

475 > EnumInfos: file_temporal_server_api_enums_v1_task_proto_enumTypes,

476 > }.Build()

477 > File_temporal_server_api_enums_v1_task_proto = out.File

478 > file_temporal_server_api_enums_v1_task_proto_goTypes = nil

479 > file_temporal_server_api_enums_v1_task_proto_depIdxs = nil

480 }

go.temporal.io/server/common/namespace/namespace.go 32 covered LOC · 11 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.

337 }

338

339 > func (id ID) String() string { namespace.go

340 > return string(id)

341 > }

342

343 func (id ID) IsEmpty() bool {

345 }

346

347 > func (n Name) String() string { namespace.go

348 > return string(n)

349 > }

350

351 func (n Name) IsEmpty() bool {

go.temporal.io/server/service/history/interfaces/engine_mock.go 32 covered LOC · 8 ranges

Open complete file

45

46 // NewMockEngine creates a new mock instance.

47 > func NewMockEngine(ctrl *gomock.Controller) *MockEngine { engine_mock.go

48 > mock := &MockEngine{ctrl: ctrl}

49 > mock.recorder = &MockEngineMockRecorder{mock}

50 > return mock

51 > }

52

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

54 > func (m *MockEngine) EXPECT() *MockEngineMockRecorder { engine_mock.go

55 > return m.recorder

56 > }

57

58 // AddTasks mocks base method.

428

429 // NotifyNewHistoryEvent mocks base method.

430 > func (m *MockEngine) NotifyNewHistoryEvent(event *events.Notification) { engine_mock.go

431 > m.ctrl.T.Helper()

432 > m.ctrl.Call(m, "NotifyNewHistoryEvent", event)

433 > }

434

435 // NotifyNewHistoryEvent indicates an expected call of NotifyNewHistoryEvent.

436 > func (mr *MockEngineMockRecorder) NotifyNewHistoryEvent(event any) *gomock.Call { engine_mock.go

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

438 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyNewHistoryEvent", reflect.TypeOf((*MockEngine)(nil).NotifyNewHistoryEvent), event)

439 > }

440

441 // NotifyNewTasks mocks base method.

442 > func (m *MockEngine) NotifyNewTasks(arg0 map[tasks.Category][]tasks.Task) { engine_mock.go

443 > m.ctrl.T.Helper()

444 > m.ctrl.Call(m, "NotifyNewTasks", arg0)

445 > }

446

447 // NotifyNewTasks indicates an expected call of NotifyNewTasks.

448 > func (mr *MockEngineMockRecorder) NotifyNewTasks(arg0 any) *gomock.Call { engine_mock.go

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

450 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyNewTasks", reflect.TypeOf((*MockEngine)(nil).NotifyNewTasks), arg0)

451 > }

452

453 // PauseActivity mocks base method.

934

935 // Stop mocks base method.

936 > func (m *MockEngine) Stop() { engine_mock.go

937 > m.ctrl.T.Helper()

938 > m.ctrl.Call(m, "Stop")

939 > }

940

941 // Stop indicates an expected call of Stop.

942 > func (mr *MockEngineMockRecorder) Stop() *gomock.Call { engine_mock.go

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

944 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockEngine)(nil).Stop))

945 > }

946

947 // SubscribeReplicationNotification mocks base method.

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/service/history/historybuilder/history_builder.go 30 covered LOC · 2 ranges

Open complete file

66 metricsHandler metrics.Handler,

67 maxEventBatchSizeInBytes dynamicconfig.IntPropertyFn,

68 > ) *HistoryBuilder { history_builder.go

69 > return &HistoryBuilder{

70 > EventStore: EventStore{

71 > state: HistoryBuilderStateMutable,

72 > timeSource: timeSource,

73 > taskIDGenerator: taskIDGenerator,

74 >

75 > version: version,

76 > nextEventID: nextEventID,

77 >

78 > workflowFinished: false,

79 >

80 > dbBufferBatch: dbBufferBatch,

81 > dbClearBuffer: false,

82 > memEventsBatches: nil,

83 > memLatestBatch: nil,

84 > memBufferBatch: nil,

85 > scheduledIDToStartedID: make(map[int64]int64),

86 > requestIDToEventID: make(map[string]int64),

87 >

88 > maxEventBatchSizeInBytes: maxEventBatchSizeInBytes,

89 >

90 > metricsHandler: metricsHandler,

91 > },

92 > EventFactory: EventFactory{timeSource: timeSource, version: version},

93 > }

94 > }

95

96 func (b *HistoryBuilder) SetTimeSource(timeSource clock.TimeSource) {

153 }

154

155 > func (b *HistoryBuilder) IsDirty() bool { history_builder.go

156 > return b.EventStore.IsDirty()

157 > }

158

159 // AddWorkflowExecutionStartedEvent

go.temporal.io/server/api/taskqueue/v1/message.pb.go 29 covered LOC · 2 ranges

Open complete file

1330 }

1331

1332 > func init() { file_temporal_server_api_taskqueue_v1_message_proto_init() } message.pb.go

1333 > func file_temporal_server_api_taskqueue_v1_message_proto_init() {

1334 > if File_temporal_server_api_taskqueue_v1_message_proto != nil {

1335 return

1336 }

1337 > file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0].OneofWrappers = []any{ message.pb.go

1338 > (*TaskVersionDirective_UseAssignmentRules)(nil),

1339 > (*TaskVersionDirective_AssignedBuildId)(nil),

1340 > }

1341 > file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5].OneofWrappers = []any{

1342 > (*TaskQueuePartition_NormalPartitionId)(nil),

1343 > (*TaskQueuePartition_StickyName)(nil),

1344 > (*TaskQueuePartition_WorkerCommands)(nil),

1345 > }

1346 > type x struct{}

1347 > out := protoimpl.TypeBuilder{

1348 > File: protoimpl.DescBuilder{

1349 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

1350 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc), len(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc)),

1351 > NumEnums: 0,

1352 > NumMessages: 16,

1353 > NumExtensions: 0,

1354 > NumServices: 0,

1355 > },

1356 > GoTypes: file_temporal_server_api_taskqueue_v1_message_proto_goTypes,

1357 > DependencyIndexes: file_temporal_server_api_taskqueue_v1_message_proto_depIdxs,

1358 > MessageInfos: file_temporal_server_api_taskqueue_v1_message_proto_msgTypes,

1359 > }.Build()

1360 > File_temporal_server_api_taskqueue_v1_message_proto = out.File

1361 > file_temporal_server_api_taskqueue_v1_message_proto_goTypes = nil

1362 > file_temporal_server_api_taskqueue_v1_message_proto_depIdxs = nil

1363 }

go.temporal.io/server/common/future/future_impl.go 29 covered LOC · 6 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 future_impl.go

47 > }

48

49 select {

67 value T,

68 err error,

69 > ) { future_impl.go

70 > // cannot directly set status to `ready`, to prevent data race in case multiple `Get` occurs

71 > // instead set status to `setting` to prevent concurrent completion of this future

72 > if !atomic.CompareAndSwapInt32(

73 > &f.status,

74 > pending,

75 > setting,

76 > ) {

77 panic("future has already been completed")

78 }

79

80 > f.value = value future_impl.go

81 > f.err = err

82 > atomic.CompareAndSwapInt32(&f.status, setting, ready)

83 > close(f.readyCh)

84 }

85

104 }

105

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

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

108 > }

go.temporal.io/server/service/history/workflow/state_machine_timers.go 29 covered LOC · 8 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 state_machine_timers.go

23 > })

24 > ms.GetExecutionInfo().StateMachineTimers = timers state_machine_timers.go

25 >

26 > if len(timers) == 0 {

27 return

28 }

29

30 > timerGroup := timers[0] state_machine_timers.go

31 > // We already have a timer for this deadline.

32 > if timerGroup.Scheduled {

33 return

34 }

35 > ms.AddTasks(&tasks.StateMachineTimerTask{ state_machine_timers.go

36 > WorkflowKey: ms.GetWorkflowKey(),

37 > VisibilityTimestamp: timerGroup.Deadline.AsTime(),

38 > Version: ms.GetCurrentVersion(),

39 > })

40 > timerGroup.Scheduled = true

41 }

42

45 // Only a single task for a given type can be tracked for a given machine. If a task of the same type is already

46 // tracked, it will be overridden.

47 > func TrackStateMachineTimer(ms historyi.MutableState, deadline time.Time, taskInfo *persistencespb.StateMachineTaskInfo) { state_machine_timers.go

48 > execInfo := ms.GetExecutionInfo()

49 > group := &persistencespb.StateMachineTimerGroup{

50 > Deadline: timestamppb.New(deadline),

51 > Infos: []*persistencespb.StateMachineTaskInfo{taskInfo},

52 > }

53 > idx, groupFound := slices.BinarySearchFunc(execInfo.StateMachineTimers, group, func(a, b *persistencespb.StateMachineTimerGroup) int {

54 return a.Deadline.AsTime().Compare(b.Deadline.AsTime())

55 })

56 > if groupFound { state_machine_timers.go

57 groupIdx := slices.IndexFunc(execInfo.StateMachineTimers[idx].Infos, func(info *persistencespb.StateMachineTaskInfo) bool {

58 return info.GetType() == taskInfo.GetType() && slices.EqualFunc(info.GetRef().GetPath(), taskInfo.GetRef().GetPath(), func(a, b *persistencespb.StateMachineKey) bool {

65 execInfo.StateMachineTimers[idx].Infos[groupIdx] = taskInfo

66 }

67 > } else { state_machine_timers.go

68 > execInfo.StateMachineTimers = slices.Insert(execInfo.StateMachineTimers, idx, group)

69 > }

70 }

71

go.temporal.io/server/api/clock/v1/message.pb.go 28 covered LOC · 5 ranges

Open complete file

45 func (*VectorClock) ProtoMessage() {}

46

47 > func (x *VectorClock) ProtoReflect() protoreflect.Message { message.pb.go

48 > mi := &file_temporal_server_api_clock_v1_message_proto_msgTypes[0]

49 > if x != nil {

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

51 if ms.LoadMessageInfo() == nil {

54 return ms

55 }

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

57 }

58

69 }

70

71 > func (x *VectorClock) GetClock() int64 { message.pb.go

72 > if x != nil {

73 > return x.Clock

74 > }

75 return 0

76 }

193 }

194

195 > func init() { file_temporal_server_api_clock_v1_message_proto_init() } message.pb.go

196 > func file_temporal_server_api_clock_v1_message_proto_init() {

197 > if File_temporal_server_api_clock_v1_message_proto != nil {

198 return

199 }

200 > type x struct{} message.pb.go

201 > out := protoimpl.TypeBuilder{

202 > File: protoimpl.DescBuilder{

203 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

204 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_clock_v1_message_proto_rawDesc), len(file_temporal_server_api_clock_v1_message_proto_rawDesc)),

205 > NumEnums: 0,

206 > NumMessages: 2,

207 > NumExtensions: 0,

208 > NumServices: 0,

209 > },

210 > GoTypes: file_temporal_server_api_clock_v1_message_proto_goTypes,

211 > DependencyIndexes: file_temporal_server_api_clock_v1_message_proto_depIdxs,

212 > MessageInfos: file_temporal_server_api_clock_v1_message_proto_msgTypes,

213 > }.Build()

214 > File_temporal_server_api_clock_v1_message_proto = out.File

215 > file_temporal_server_api_clock_v1_message_proto_goTypes = nil

216 > file_temporal_server_api_clock_v1_message_proto_depIdxs = nil

217 }

go.temporal.io/server/client/client_bean_mock.go 28 covered LOC · 7 ranges

Open complete file

34

35 // NewMockBean creates a new mock instance.

36 > func NewMockBean(ctrl *gomock.Controller) *MockBean { client_bean_mock.go

37 > mock := &MockBean{ctrl: ctrl}

38 > mock.recorder = &MockBeanMockRecorder{mock}

39 > return mock

40 > }

41

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

43 > func (m *MockBean) EXPECT() *MockBeanMockRecorder { client_bean_mock.go

44 > return m.recorder

45 > }

46

47 // Close mocks base method.

66

67 // GetFrontendClient indicates an expected call of GetFrontendClient.

68 > func (mr *MockBeanMockRecorder) GetFrontendClient() *gomock.Call { client_bean_mock.go

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

70 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFrontendClient", reflect.TypeOf((*MockBean)(nil).GetFrontendClient))

71 > }

72

73 // GetHistoryClient mocks base method.

80

81 // GetHistoryClient indicates an expected call of GetHistoryClient.

82 > func (mr *MockBeanMockRecorder) GetHistoryClient() *gomock.Call { client_bean_mock.go

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

84 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryClient", reflect.TypeOf((*MockBean)(nil).GetHistoryClient))

85 > }

86

87 // GetMatchingClient mocks base method.

95

96 // GetMatchingClient indicates an expected call of GetMatchingClient.

97 > func (mr *MockBeanMockRecorder) GetMatchingClient(namespaceIDToName any) *gomock.Call { client_bean_mock.go

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

99 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMatchingClient", reflect.TypeOf((*MockBean)(nil).GetMatchingClient), namespaceIDToName)

100 > }

101

102 // GetRemoteAdminClient mocks base method.

110

111 // GetRemoteAdminClient indicates an expected call of GetRemoteAdminClient.

112 > func (mr *MockBeanMockRecorder) GetRemoteAdminClient(arg0 any) *gomock.Call { client_bean_mock.go

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

114 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteAdminClient", reflect.TypeOf((*MockBean)(nil).GetRemoteAdminClient), arg0)

115 > }

116

117 // GetRemoteFrontendClient mocks base method.

126

127 // GetRemoteFrontendClient indicates an expected call of GetRemoteFrontendClient.

128 > func (mr *MockBeanMockRecorder) GetRemoteFrontendClient(arg0 any) *gomock.Call { client_bean_mock.go

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

130 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteFrontendClient", reflect.TypeOf((*MockBean)(nil).GetRemoteFrontendClient), arg0)

131 > }

go.temporal.io/server/service/history/shard/task_key_manager.go 28 covered LOC · 5 ranges

Open complete file

28 logger log.Logger,

29 renewRangeIDFn renewRangeIDFn,

30 > ) *taskKeyManager { task_key_manager.go

31 > return &taskKeyManager{

32 > generator: newTaskKeyGenerator(

33 > config.RangeSizeBits,

34 > timeSource,

35 > logger,

36 > renewRangeIDFn,

37 > ),

38 > tracker: newTaskRequestTracker(taskCategoryRegistry),

39 > timeSource: timeSource,

40 > logger: logger,

41 > config: config,

42 > }

43 > }

44

45 func (m *taskKeyManager) setAndTrackTaskKeys(

46 taskMaps ...map[tasks.Category][]tasks.Task,

47 > ) (taskRequestCompletionFn, error) { task_key_manager.go

48 >

49 > if err := m.generator.setTaskKeys(taskMaps...); err != nil {

50 return nil, err

51 }

52

53 > return m.tracker.track(taskMaps...), nil task_key_manager.go

54 }

55

56 func (m *taskKeyManager) peekTaskKey(

57 category tasks.Category,

58 > ) tasks.Key { task_key_manager.go

59 > return m.generator.peekTaskKey(category)

60 > }

61

62 func (m *taskKeyManager) generateTaskKey(

72 func (m *taskKeyManager) setRangeID(

73 rangeID int64,

74 > ) { task_key_manager.go

75 > m.generator.setRangeID(rangeID)

76 >

77 > // rangeID update means all pending add tasks requests either already succeeded

78 > // are guaranteed to fail, so we can clear pending requests in the tracker

79 > m.tracker.clear()

80 > }

81

82 func (m *taskKeyManager) setTaskMinScheduledTime(

go.temporal.io/server/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/hsm/hsmtest/sm.go 27 covered LOC · 6 ranges

Open complete file

42 }

43

44 > func (d *Data) RegenerateTasks(node *hsm.Node) ([]hsm.Task, error) { sm.go

45 > return []hsm.Task{

46 > NewTask(

47 > hsm.TaskAttributes{Deadline: time.Now().Add(time.Hour)},

48 > false,

49 > ),

50 > NewTask(

51 > hsm.TaskAttributes{Destination: string(d.state)},

52 > false,

53 > ),

54 > }, nil

55 > }

56

57 type Definition struct {

59 }

60

61 > func NewDefinition(typeName string) Definition { sm.go

62 > return Definition{

63 > typeName: typeName,

64 > }

65 > }

66

67 > func (d Definition) Deserialize(b []byte) (any, error) { sm.go

68 > return &Data{State(string(b))}, nil

69 > }

70

71 // Serialize implements hsm.StateMachineDefinition.

72 > func (d Definition) Serialize(s any) ([]byte, error) { sm.go

73 > t, ok := s.(*Data)

74 > if !ok {

75 return nil, errInvalidStateType

76 }

77 > return []byte(t.state), nil sm.go

78 }

79

80 // Type implements hsm.StateMachineDefinition.

81 > func (d Definition) Type() string { sm.go

82 > return d.typeName

83 > }

84

85 func (d Definition) CompareState(s1 any, s2 any) (int, error) {

go.temporal.io/server/service/history/hsm/registry.go 27 covered LOC · 7 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.

78 // Returns an [ErrDuplicateRegistration] if a serializer for this task type has already been registered.

79 > func (r *Registry) RegisterTaskSerializer(t string, def TaskSerializer) error { registry.go

80 > if exising, ok := r.tasks[t]; ok {

81 return fmt.Errorf("%w: task already registered for %v: %v", ErrDuplicateRegistration, t, exising)

82 }

83 > r.tasks[t] = def registry.go

84 > return nil

85 }

86

87 // TaskSerializer returns a [TaskSerializer] for a given type and a boolean indicating whether it was found.

88 > func (r *Registry) TaskSerializer(t string) (d TaskSerializer, ok bool) { registry.go

89 > d, ok = r.tasks[t]

90 > return

91 > }

92

93 // RegisterImmediateExecutor registers an [ImmediateExecutor] for the given task type.

go.temporal.io/server/api/enums/v1/common.pb.go 26 covered LOC · 4 ranges

Open complete file

120 }

121

122 > func (ChecksumFlavor) Descriptor() protoreflect.EnumDescriptor { common.pb.go

123 > return file_temporal_server_api_enums_v1_common_proto_enumTypes[1].Descriptor()

124 > }

125

126 func (ChecksumFlavor) Type() protoreflect.EnumType {

201 }

202

203 > func (CallbackState) Descriptor() protoreflect.EnumDescriptor { common.pb.go

204 > return file_temporal_server_api_enums_v1_common_proto_enumTypes[2].Descriptor()

205 > }

206

207 func (CallbackState) Type() protoreflect.EnumType {

264 }

265

266 > func init() { file_temporal_server_api_enums_v1_common_proto_init() } common.pb.go

267 > func file_temporal_server_api_enums_v1_common_proto_init() {

268 > if File_temporal_server_api_enums_v1_common_proto != nil {

269 return

270 }

271 > type x struct{} common.pb.go

272 > out := protoimpl.TypeBuilder{

273 > File: protoimpl.DescBuilder{

274 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

275 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_common_proto_rawDesc), len(file_temporal_server_api_enums_v1_common_proto_rawDesc)),

276 > NumEnums: 3,

277 > NumMessages: 0,

278 > NumExtensions: 0,

279 > NumServices: 0,

280 > },

281 > GoTypes: file_temporal_server_api_enums_v1_common_proto_goTypes,

282 > DependencyIndexes: file_temporal_server_api_enums_v1_common_proto_depIdxs,

283 > EnumInfos: file_temporal_server_api_enums_v1_common_proto_enumTypes,

284 > }.Build()

285 > File_temporal_server_api_enums_v1_common_proto = out.File

286 > file_temporal_server_api_enums_v1_common_proto_goTypes = nil

287 > file_temporal_server_api_enums_v1_common_proto_depIdxs = nil

288 }

go.temporal.io/server/api/enums/v1/workflow.pb.go 26 covered LOC · 4 ranges

Open complete file

86 }

87

88 > func (WorkflowExecutionState) Descriptor() protoreflect.EnumDescriptor { workflow.pb.go

89 > return file_temporal_server_api_enums_v1_workflow_proto_enumTypes[0].Descriptor()

90 > }

91

92 func (WorkflowExecutionState) Type() protoreflect.EnumType {

150 }

151

152 > func (WorkflowBackoffType) Descriptor() protoreflect.EnumDescriptor { workflow.pb.go

153 > return file_temporal_server_api_enums_v1_workflow_proto_enumTypes[1].Descriptor()

154 > }

155

156 func (WorkflowBackoffType) Type() protoreflect.EnumType {

275 }

276

277 > func init() { file_temporal_server_api_enums_v1_workflow_proto_init() } workflow.pb.go

278 > func file_temporal_server_api_enums_v1_workflow_proto_init() {

279 > if File_temporal_server_api_enums_v1_workflow_proto != nil {

280 return

281 }

282 > type x struct{} workflow.pb.go

283 > out := protoimpl.TypeBuilder{

284 > File: protoimpl.DescBuilder{

285 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

286 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_proto_rawDesc)),

287 > NumEnums: 3,

288 > NumMessages: 0,

289 > NumExtensions: 0,

290 > NumServices: 0,

291 > },

292 > GoTypes: file_temporal_server_api_enums_v1_workflow_proto_goTypes,

293 > DependencyIndexes: file_temporal_server_api_enums_v1_workflow_proto_depIdxs,

294 > EnumInfos: file_temporal_server_api_enums_v1_workflow_proto_enumTypes,

295 > }.Build()

296 > File_temporal_server_api_enums_v1_workflow_proto = out.File

297 > file_temporal_server_api_enums_v1_workflow_proto_goTypes = nil

298 > file_temporal_server_api_enums_v1_workflow_proto_depIdxs = nil

299 }

go.temporal.io/server/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/common/metrics/tags.go 24 covered LOC · 12 ranges

Open complete file

101 // dual emit the metric with the all tag. If a blank namespace is provided then

102 // this converts that to an unknown namespace.

103 > func NamespaceTag(value string) Tag { tags.go

104 > if len(value) == 0 {

105 value = unknownValue

106 }

107 > return Tag{Key: namespace, Value: value} tags.go

108 }

109

110 // NamespaceIDTag returns a new namespace ID tag.

111 > func NamespaceIDTag(value string) Tag { tags.go

112 > if len(value) == 0 {

113 value = unknownValue

114 }

115 > return Tag{Key: namespaceID, Value: value} tags.go

116 }

117

124

125 // NamespaceStateTag returns a new namespace state tag.

126 > func NamespaceStateTag(value string) Tag { tags.go

127 > if len(value) == 0 {

128 value = unknownValue

129 }

130 > return Tag{Key: namespaceState, Value: value} tags.go

131 }

132

286 }

287

288 > func ArchetypeTag(value string) Tag { tags.go

289 > if len(value) == 0 {

290 value = unknownValue

291 }

292 > return Tag{Key: ArchetypeTagName, Value: value} tags.go

293 }

294

447 }

448

449 > func ServiceNameTag(value primitives.ServiceName) Tag { tags.go

450 > return Tag{Key: serviceName, Value: string(value)}

451 > }

452

453 func ActionType(value string) Tag {

455 }

456

457 > func OperationTag(value string) Tag { tags.go

458 > return Tag{Key: OperationTagName, Value: value}

459 > }

460

461 func StringTag(key string, value string) Tag {

463 }

464

465 > func CacheTypeTag(value string) Tag { tags.go

466 > return Tag{Key: CacheTypeTagName, Value: value}

467 > }

468

469 > func PriorityTag(value locks.Priority) Tag { tags.go

470 > return Tag{Key: PriorityTagName, Value: strconv.Itoa(int(value))}

471 > }

472

473 // ReasonString is just a string but the special type is defined here to remind callers of ReasonTag to limit the

go.temporal.io/server/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/common/log/tag/zap_tag.go 23 covered LOC · 5 ranges

Open complete file

26 }

27

28 > func (t ZapTag) Field() zap.Field { zap_tag.go

29 > return t.field

30 > }

31

32 func (t ZapTag) Key() string {

44 }

45

46 > func NewStringTag(key string, value string) ZapTag { zap_tag.go

47 > return ZapTag{

48 > field: zap.String(key, value),

49 > }

50 > }

51

52 func NewStringsTag(key string, value []string) ZapTag {

82 }

83

84 > func NewInt64(key string, value int64) ZapTag { zap_tag.go

85 > return ZapTag{

86 > field: zap.Int64(key, value),

87 > }

88 > }

89

90 func NewInt(key string, value int) ZapTag {

118 }

119

120 > func NewBoolTag(key string, value bool) ZapTag { zap_tag.go

121 > return ZapTag{

122 > field: zap.Bool(key, value),

123 > }

124 > }

125

126 func NewErrorTag(key string, value error) ZapTag {

142 }

143

144 > func NewTimeTag(key string, value time.Time) ZapTag { zap_tag.go

145 > return ZapTag{

146 > field: zap.Time(key, value),

147 > }

148 > }

149

150 func NewTimePtrTag(key string, value *timestamppb.Timestamp) ZapTag {

go.temporal.io/server/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/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/common/persistence/versionhistory/version_histories.go 21 covered LOC · 8 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

20 // Copy VersionHistories.

21 > func CopyVersionHistories(h *historyspb.VersionHistories) *historyspb.VersionHistories { version_histories.go

22 > var histories []*historyspb.VersionHistory

23 > for _, history := range h.Histories {

24 > histories = append(histories, CopyVersionHistory(history)) version_histories.go

25 > }

26

27 > return &historyspb.VersionHistories{ version_histories.go

28 > CurrentVersionHistoryIndex: h.CurrentVersionHistoryIndex,

29 > Histories: histories,

30 > }

31 }

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/service/history/hsm/hsmtest/task.go 21 covered LOC · 8 ranges

Open complete file

24 attrs hsm.TaskAttributes,

25 concurrent bool,

26 > ) *Task { task.go

27 > return &Task{

28 > attrs: attrs,

29 > IsConcurrent: concurrent,

30 > }

31 > }

32

33 > func (t *Task) Type() string { task.go

34 > return TaskType

35 > }

36

37 > func (t *Task) Deadline() time.Time { task.go

38 > return t.attrs.Deadline

39 > }

40

41 > func (t *Task) Destination() string { task.go

42 > return t.attrs.Destination

43 > }

44

45 > func (t *Task) Validate(ref *persistencespb.StateMachineRef, node *hsm.Node) error { task.go

46 > if t.IsConcurrent {

47 return hsm.ValidateNotTransitioned(ref, node)

48 }

49 > return nil task.go

50 }

51

52 type TaskSerializer struct{}

53

54 > func (s TaskSerializer) Serialize(t hsm.Task) ([]byte, error) { task.go

55 > if t.Type() != TaskType {

56 return nil, errInvalidTaskType

57 }

58 > return json.Marshal(t) task.go

59 }

60

go.temporal.io/server/api/adminservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

273 }

274

275 > func init() { file_temporal_server_api_adminservice_v1_service_proto_init() } service.pb.go

276 > func file_temporal_server_api_adminservice_v1_service_proto_init() {

277 > if File_temporal_server_api_adminservice_v1_service_proto != nil {

278 return

279 }

280 > file_temporal_server_api_adminservice_v1_request_response_proto_init() service.pb.go

281 > type x struct{}

282 > out := protoimpl.TypeBuilder{

283 > File: protoimpl.DescBuilder{

284 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

285 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_adminservice_v1_service_proto_rawDesc), len(file_temporal_server_api_adminservice_v1_service_proto_rawDesc)),

286 > NumEnums: 0,

287 > NumMessages: 0,

288 > NumExtensions: 0,

289 > NumServices: 1,

290 > },

291 > GoTypes: file_temporal_server_api_adminservice_v1_service_proto_goTypes,

292 > DependencyIndexes: file_temporal_server_api_adminservice_v1_service_proto_depIdxs,

293 > }.Build()

294 > File_temporal_server_api_adminservice_v1_service_proto = out.File

295 > file_temporal_server_api_adminservice_v1_service_proto_goTypes = nil

296 > file_temporal_server_api_adminservice_v1_service_proto_depIdxs = nil

297 }

go.temporal.io/server/api/archiver/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

431 }

432

433 > func init() { file_temporal_server_api_archiver_v1_message_proto_init() } message.pb.go

434 > func file_temporal_server_api_archiver_v1_message_proto_init() {

435 > if File_temporal_server_api_archiver_v1_message_proto != nil {

436 return

437 }

438 > type x struct{} message.pb.go

439 > out := protoimpl.TypeBuilder{

440 > File: protoimpl.DescBuilder{

441 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

442 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_archiver_v1_message_proto_rawDesc), len(file_temporal_server_api_archiver_v1_message_proto_rawDesc)),

443 > NumEnums: 0,

444 > NumMessages: 4,

445 > NumExtensions: 0,

446 > NumServices: 0,

447 > },

448 > GoTypes: file_temporal_server_api_archiver_v1_message_proto_goTypes,

449 > DependencyIndexes: file_temporal_server_api_archiver_v1_message_proto_depIdxs,

450 > MessageInfos: file_temporal_server_api_archiver_v1_message_proto_msgTypes,

451 > }.Build()

452 > File_temporal_server_api_archiver_v1_message_proto = out.File

453 > file_temporal_server_api_archiver_v1_message_proto_goTypes = nil

454 > file_temporal_server_api_archiver_v1_message_proto_depIdxs = nil

455 }

go.temporal.io/server/api/chasm/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

206 }

207

208 > func init() { file_temporal_server_api_chasm_v1_message_proto_init() } message.pb.go

209 > func file_temporal_server_api_chasm_v1_message_proto_init() {

210 > if File_temporal_server_api_chasm_v1_message_proto != nil {

211 return

212 }

213 > type x struct{} message.pb.go

214 > out := protoimpl.TypeBuilder{

215 > File: protoimpl.DescBuilder{

216 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

217 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_chasm_v1_message_proto_rawDesc), len(file_temporal_server_api_chasm_v1_message_proto_rawDesc)),

218 > NumEnums: 0,

219 > NumMessages: 1,

220 > NumExtensions: 0,

221 > NumServices: 0,

222 > },

223 > GoTypes: file_temporal_server_api_chasm_v1_message_proto_goTypes,

224 > DependencyIndexes: file_temporal_server_api_chasm_v1_message_proto_depIdxs,

225 > MessageInfos: file_temporal_server_api_chasm_v1_message_proto_msgTypes,

226 > }.Build()

227 > File_temporal_server_api_chasm_v1_message_proto = out.File

228 > file_temporal_server_api_chasm_v1_message_proto_goTypes = nil

229 > file_temporal_server_api_chasm_v1_message_proto_depIdxs = nil

230 }

go.temporal.io/server/api/checksum/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

334 }

335

336 > func init() { file_temporal_server_api_checksum_v1_message_proto_init() } message.pb.go

337 > func file_temporal_server_api_checksum_v1_message_proto_init() {

338 > if File_temporal_server_api_checksum_v1_message_proto != nil {

339 return

340 }

341 > type x struct{} message.pb.go

342 > out := protoimpl.TypeBuilder{

343 > File: protoimpl.DescBuilder{

344 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

345 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_checksum_v1_message_proto_rawDesc), len(file_temporal_server_api_checksum_v1_message_proto_rawDesc)),

346 > NumEnums: 0,

347 > NumMessages: 1,

348 > NumExtensions: 0,

349 > NumServices: 0,

350 > },

351 > GoTypes: file_temporal_server_api_checksum_v1_message_proto_goTypes,

352 > DependencyIndexes: file_temporal_server_api_checksum_v1_message_proto_depIdxs,

353 > MessageInfos: file_temporal_server_api_checksum_v1_message_proto_msgTypes,

354 > }.Build()

355 > File_temporal_server_api_checksum_v1_message_proto = out.File

356 > file_temporal_server_api_checksum_v1_message_proto_goTypes = nil

357 > file_temporal_server_api_checksum_v1_message_proto_depIdxs = nil

358 }

go.temporal.io/server/api/cluster/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

342 }

343

344 > func init() { file_temporal_server_api_cluster_v1_message_proto_init() } message.pb.go

345 > func file_temporal_server_api_cluster_v1_message_proto_init() {

346 > if File_temporal_server_api_cluster_v1_message_proto != nil {

347 return

348 }

349 > type x struct{} message.pb.go

350 > out := protoimpl.TypeBuilder{

351 > File: protoimpl.DescBuilder{

352 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

353 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_cluster_v1_message_proto_rawDesc), len(file_temporal_server_api_cluster_v1_message_proto_rawDesc)),

354 > NumEnums: 0,

355 > NumMessages: 4,

356 > NumExtensions: 0,

357 > NumServices: 0,

358 > },

359 > GoTypes: file_temporal_server_api_cluster_v1_message_proto_goTypes,

360 > DependencyIndexes: file_temporal_server_api_cluster_v1_message_proto_depIdxs,

361 > MessageInfos: file_temporal_server_api_cluster_v1_message_proto_msgTypes,

362 > }.Build()

363 > File_temporal_server_api_cluster_v1_message_proto = out.File

364 > file_temporal_server_api_cluster_v1_message_proto_goTypes = nil

365 > file_temporal_server_api_cluster_v1_message_proto_depIdxs = nil

366 }

go.temporal.io/server/api/common/v1/dlq.pb.go 20 covered LOC · 2 ranges

Open complete file

295 }

296

297 > func init() { file_temporal_server_api_common_v1_dlq_proto_init() } dlq.pb.go

298 > func file_temporal_server_api_common_v1_dlq_proto_init() {

299 > if File_temporal_server_api_common_v1_dlq_proto != nil {

300 return

301 }

302 > type x struct{} dlq.pb.go

303 > out := protoimpl.TypeBuilder{

304 > File: protoimpl.DescBuilder{

305 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

306 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_common_v1_dlq_proto_rawDesc), len(file_temporal_server_api_common_v1_dlq_proto_rawDesc)),

307 > NumEnums: 0,

308 > NumMessages: 4,

309 > NumExtensions: 0,

310 > NumServices: 0,

311 > },

312 > GoTypes: file_temporal_server_api_common_v1_dlq_proto_goTypes,

313 > DependencyIndexes: file_temporal_server_api_common_v1_dlq_proto_depIdxs,

314 > MessageInfos: file_temporal_server_api_common_v1_dlq_proto_msgTypes,

315 > }.Build()

316 > File_temporal_server_api_common_v1_dlq_proto = out.File

317 > file_temporal_server_api_common_v1_dlq_proto_goTypes = nil

318 > file_temporal_server_api_common_v1_dlq_proto_depIdxs = nil

319 }

go.temporal.io/server/api/contextpropagation/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

109 }

110

111 > func init() { file_temporal_server_api_contextpropagation_v1_message_proto_init() } message.pb.go

112 > func file_temporal_server_api_contextpropagation_v1_message_proto_init() {

113 > if File_temporal_server_api_contextpropagation_v1_message_proto != nil {

114 return

115 }

116 > type x struct{} message.pb.go

117 > out := protoimpl.TypeBuilder{

118 > File: protoimpl.DescBuilder{

119 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

120 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_contextpropagation_v1_message_proto_rawDesc), len(file_temporal_server_api_contextpropagation_v1_message_proto_rawDesc)),

121 > NumEnums: 0,

122 > NumMessages: 2,

123 > NumExtensions: 0,

124 > NumServices: 0,

125 > },

126 > GoTypes: file_temporal_server_api_contextpropagation_v1_message_proto_goTypes,

127 > DependencyIndexes: file_temporal_server_api_contextpropagation_v1_message_proto_depIdxs,

128 > MessageInfos: file_temporal_server_api_contextpropagation_v1_message_proto_msgTypes,

129 > }.Build()

130 > File_temporal_server_api_contextpropagation_v1_message_proto = out.File

131 > file_temporal_server_api_contextpropagation_v1_message_proto_goTypes = nil

132 > file_temporal_server_api_contextpropagation_v1_message_proto_depIdxs = nil

133 }

go.temporal.io/server/api/deployment/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

4626 }

4627

4628 > func init() { file_temporal_server_api_deployment_v1_message_proto_init() } message.pb.go

4629 > func file_temporal_server_api_deployment_v1_message_proto_init() {

4630 > if File_temporal_server_api_deployment_v1_message_proto != nil {

4631 return

4632 }

4633 > type x struct{} message.pb.go

4634 > out := protoimpl.TypeBuilder{

4635 > File: protoimpl.DescBuilder{

4636 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

4637 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_deployment_v1_message_proto_rawDesc), len(file_temporal_server_api_deployment_v1_message_proto_rawDesc)),

4638 > NumEnums: 0,

4639 > NumMessages: 75,

4640 > NumExtensions: 0,

4641 > NumServices: 0,

4642 > },

4643 > GoTypes: file_temporal_server_api_deployment_v1_message_proto_goTypes,

4644 > DependencyIndexes: file_temporal_server_api_deployment_v1_message_proto_depIdxs,

4645 > MessageInfos: file_temporal_server_api_deployment_v1_message_proto_msgTypes,

4646 > }.Build()

4647 > File_temporal_server_api_deployment_v1_message_proto = out.File

4648 > file_temporal_server_api_deployment_v1_message_proto_goTypes = nil

4649 > file_temporal_server_api_deployment_v1_message_proto_depIdxs = nil

4650 }

go.temporal.io/server/api/enums/v1/cluster.pb.go 20 covered LOC · 2 ranges

Open complete file

209 }

210

211 > func init() { file_temporal_server_api_enums_v1_cluster_proto_init() } cluster.pb.go

212 > func file_temporal_server_api_enums_v1_cluster_proto_init() {

213 > if File_temporal_server_api_enums_v1_cluster_proto != nil {

214 return

215 }

216 > type x struct{} cluster.pb.go

217 > out := protoimpl.TypeBuilder{

218 > File: protoimpl.DescBuilder{

219 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

220 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_cluster_proto_rawDesc), len(file_temporal_server_api_enums_v1_cluster_proto_rawDesc)),

221 > NumEnums: 2,

222 > NumMessages: 0,

223 > NumExtensions: 0,

224 > NumServices: 0,

225 > },

226 > GoTypes: file_temporal_server_api_enums_v1_cluster_proto_goTypes,

227 > DependencyIndexes: file_temporal_server_api_enums_v1_cluster_proto_depIdxs,

228 > EnumInfos: file_temporal_server_api_enums_v1_cluster_proto_enumTypes,

229 > }.Build()

230 > File_temporal_server_api_enums_v1_cluster_proto = out.File

231 > file_temporal_server_api_enums_v1_cluster_proto_goTypes = nil

232 > file_temporal_server_api_enums_v1_cluster_proto_depIdxs = nil

233 }

go.temporal.io/server/api/enums/v1/dlq.pb.go 20 covered LOC · 2 ranges

Open complete file

187 }

188

189 > func init() { file_temporal_server_api_enums_v1_dlq_proto_init() } dlq.pb.go

190 > func file_temporal_server_api_enums_v1_dlq_proto_init() {

191 > if File_temporal_server_api_enums_v1_dlq_proto != nil {

192 return

193 }

194 > type x struct{} dlq.pb.go

195 > out := protoimpl.TypeBuilder{

196 > File: protoimpl.DescBuilder{

197 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

198 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_dlq_proto_rawDesc), len(file_temporal_server_api_enums_v1_dlq_proto_rawDesc)),

199 > NumEnums: 2,

200 > NumMessages: 0,

201 > NumExtensions: 0,

202 > NumServices: 0,

203 > },

204 > GoTypes: file_temporal_server_api_enums_v1_dlq_proto_goTypes,

205 > DependencyIndexes: file_temporal_server_api_enums_v1_dlq_proto_depIdxs,

206 > EnumInfos: file_temporal_server_api_enums_v1_dlq_proto_enumTypes,

207 > }.Build()

208 > File_temporal_server_api_enums_v1_dlq_proto = out.File

209 > file_temporal_server_api_enums_v1_dlq_proto_goTypes = nil

210 > file_temporal_server_api_enums_v1_dlq_proto_depIdxs = nil

211 }

go.temporal.io/server/api/enums/v1/fairness_state.pb.go 20 covered LOC · 2 ranges

Open complete file

123 }

124

125 > func init() { file_temporal_server_api_enums_v1_fairness_state_proto_init() } fairness_state.pb.go

126 > func file_temporal_server_api_enums_v1_fairness_state_proto_init() {

127 > if File_temporal_server_api_enums_v1_fairness_state_proto != nil {

128 return

129 }

130 > type x struct{} fairness_state.pb.go

131 > out := protoimpl.TypeBuilder{

132 > File: protoimpl.DescBuilder{

133 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

134 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc), len(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc)),

135 > NumEnums: 1,

136 > NumMessages: 0,

137 > NumExtensions: 0,

138 > NumServices: 0,

139 > },

140 > GoTypes: file_temporal_server_api_enums_v1_fairness_state_proto_goTypes,

141 > DependencyIndexes: file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs,

142 > EnumInfos: file_temporal_server_api_enums_v1_fairness_state_proto_enumTypes,

143 > }.Build()

144 > File_temporal_server_api_enums_v1_fairness_state_proto = out.File

145 > file_temporal_server_api_enums_v1_fairness_state_proto_goTypes = nil

146 > file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs = nil

147 }

go.temporal.io/server/api/enums/v1/replication.pb.go 20 covered LOC · 2 ranges

Open complete file

314 }

315

316 > func init() { file_temporal_server_api_enums_v1_replication_proto_init() } replication.pb.go

317 > func file_temporal_server_api_enums_v1_replication_proto_init() {

318 > if File_temporal_server_api_enums_v1_replication_proto != nil {

319 return

320 }

321 > type x struct{} replication.pb.go

322 > out := protoimpl.TypeBuilder{

323 > File: protoimpl.DescBuilder{

324 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

325 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_replication_proto_rawDesc), len(file_temporal_server_api_enums_v1_replication_proto_rawDesc)),

326 > NumEnums: 3,

327 > NumMessages: 0,

328 > NumExtensions: 0,

329 > NumServices: 0,

330 > },

331 > GoTypes: file_temporal_server_api_enums_v1_replication_proto_goTypes,

332 > DependencyIndexes: file_temporal_server_api_enums_v1_replication_proto_depIdxs,

333 > EnumInfos: file_temporal_server_api_enums_v1_replication_proto_enumTypes,

334 > }.Build()

335 > File_temporal_server_api_enums_v1_replication_proto = out.File

336 > file_temporal_server_api_enums_v1_replication_proto_goTypes = nil

337 > file_temporal_server_api_enums_v1_replication_proto_depIdxs = nil

338 }

go.temporal.io/server/api/errordetails/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

625 }

626

627 > func init() { file_temporal_server_api_errordetails_v1_message_proto_init() } message.pb.go

628 > func file_temporal_server_api_errordetails_v1_message_proto_init() {

629 > if File_temporal_server_api_errordetails_v1_message_proto != nil {

630 return

631 }

632 > type x struct{} message.pb.go

633 > out := protoimpl.TypeBuilder{

634 > File: protoimpl.DescBuilder{

635 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

636 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_errordetails_v1_message_proto_rawDesc), len(file_temporal_server_api_errordetails_v1_message_proto_rawDesc)),

637 > NumEnums: 0,

638 > NumMessages: 10,

639 > NumExtensions: 0,

640 > NumServices: 0,

641 > },

642 > GoTypes: file_temporal_server_api_errordetails_v1_message_proto_goTypes,

643 > DependencyIndexes: file_temporal_server_api_errordetails_v1_message_proto_depIdxs,

644 > MessageInfos: file_temporal_server_api_errordetails_v1_message_proto_msgTypes,

645 > }.Build()

646 > File_temporal_server_api_errordetails_v1_message_proto = out.File

647 > file_temporal_server_api_errordetails_v1_message_proto_goTypes = nil

648 > file_temporal_server_api_errordetails_v1_message_proto_depIdxs = nil

649 }

go.temporal.io/server/api/health/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

300 }

301

302 > func init() { file_temporal_server_api_health_v1_message_proto_init() } message.pb.go

303 > func file_temporal_server_api_health_v1_message_proto_init() {

304 > if File_temporal_server_api_health_v1_message_proto != nil {

305 return

306 }

307 > type x struct{} message.pb.go

308 > out := protoimpl.TypeBuilder{

309 > File: protoimpl.DescBuilder{

310 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

311 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_health_v1_message_proto_rawDesc), len(file_temporal_server_api_health_v1_message_proto_rawDesc)),

312 > NumEnums: 0,

313 > NumMessages: 3,

314 > NumExtensions: 0,

315 > NumServices: 0,

316 > },

317 > GoTypes: file_temporal_server_api_health_v1_message_proto_goTypes,

318 > DependencyIndexes: file_temporal_server_api_health_v1_message_proto_depIdxs,

319 > MessageInfos: file_temporal_server_api_health_v1_message_proto_msgTypes,

320 > }.Build()

321 > File_temporal_server_api_health_v1_message_proto = out.File

322 > file_temporal_server_api_health_v1_message_proto_goTypes = nil

323 > file_temporal_server_api_health_v1_message_proto_depIdxs = nil

324 }

go.temporal.io/server/api/historyservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

428 }

429

430 > func init() { file_temporal_server_api_historyservice_v1_service_proto_init() } service.pb.go

431 > func file_temporal_server_api_historyservice_v1_service_proto_init() {

432 > if File_temporal_server_api_historyservice_v1_service_proto != nil {

433 return

434 }

435 > file_temporal_server_api_historyservice_v1_request_response_proto_init() service.pb.go

436 > type x struct{}

437 > out := protoimpl.TypeBuilder{

438 > File: protoimpl.DescBuilder{

439 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

440 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_historyservice_v1_service_proto_rawDesc), len(file_temporal_server_api_historyservice_v1_service_proto_rawDesc)),

441 > NumEnums: 0,

442 > NumMessages: 0,

443 > NumExtensions: 0,

444 > NumServices: 1,

445 > },

446 > GoTypes: file_temporal_server_api_historyservice_v1_service_proto_goTypes,

447 > DependencyIndexes: file_temporal_server_api_historyservice_v1_service_proto_depIdxs,

448 > }.Build()

449 > File_temporal_server_api_historyservice_v1_service_proto = out.File

450 > file_temporal_server_api_historyservice_v1_service_proto_goTypes = nil

451 > file_temporal_server_api_historyservice_v1_service_proto_depIdxs = nil

452 }

go.temporal.io/server/api/matchingservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

250 }

251

252 > func init() { file_temporal_server_api_matchingservice_v1_service_proto_init() } service.pb.go

253 > func file_temporal_server_api_matchingservice_v1_service_proto_init() {

254 > if File_temporal_server_api_matchingservice_v1_service_proto != nil {

255 return

256 }

257 > file_temporal_server_api_matchingservice_v1_request_response_proto_init() service.pb.go

258 > type x struct{}

259 > out := protoimpl.TypeBuilder{

260 > File: protoimpl.DescBuilder{

261 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

262 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_matchingservice_v1_service_proto_rawDesc), len(file_temporal_server_api_matchingservice_v1_service_proto_rawDesc)),

263 > NumEnums: 0,

264 > NumMessages: 0,

265 > NumExtensions: 0,

266 > NumServices: 1,

267 > },

268 > GoTypes: file_temporal_server_api_matchingservice_v1_service_proto_goTypes,

269 > DependencyIndexes: file_temporal_server_api_matchingservice_v1_service_proto_depIdxs,

270 > }.Build()

271 > File_temporal_server_api_matchingservice_v1_service_proto = out.File

272 > file_temporal_server_api_matchingservice_v1_service_proto_goTypes = nil

273 > file_temporal_server_api_matchingservice_v1_service_proto_depIdxs = nil

274 }

go.temporal.io/server/api/metrics/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

104 }

105

106 > func init() { file_temporal_server_api_metrics_v1_message_proto_init() } message.pb.go

107 > func file_temporal_server_api_metrics_v1_message_proto_init() {

108 > if File_temporal_server_api_metrics_v1_message_proto != nil {

109 return

110 }

111 > type x struct{} message.pb.go

112 > out := protoimpl.TypeBuilder{

113 > File: protoimpl.DescBuilder{

114 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

115 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_metrics_v1_message_proto_rawDesc), len(file_temporal_server_api_metrics_v1_message_proto_rawDesc)),

116 > NumEnums: 0,

117 > NumMessages: 2,

118 > NumExtensions: 0,

119 > NumServices: 0,

120 > },

121 > GoTypes: file_temporal_server_api_metrics_v1_message_proto_goTypes,

122 > DependencyIndexes: file_temporal_server_api_metrics_v1_message_proto_depIdxs,

123 > MessageInfos: file_temporal_server_api_metrics_v1_message_proto_msgTypes,

124 > }.Build()

125 > File_temporal_server_api_metrics_v1_message_proto = out.File

126 > file_temporal_server_api_metrics_v1_message_proto_goTypes = nil

127 > file_temporal_server_api_metrics_v1_message_proto_depIdxs = nil

128 }

go.temporal.io/server/api/namespace/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

114 }

115

116 > func init() { file_temporal_server_api_namespace_v1_message_proto_init() } message.pb.go

117 > func file_temporal_server_api_namespace_v1_message_proto_init() {

118 > if File_temporal_server_api_namespace_v1_message_proto != nil {

119 return

120 }

121 > type x struct{} message.pb.go

122 > out := protoimpl.TypeBuilder{

123 > File: protoimpl.DescBuilder{

124 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

125 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_namespace_v1_message_proto_rawDesc), len(file_temporal_server_api_namespace_v1_message_proto_rawDesc)),

126 > NumEnums: 0,

127 > NumMessages: 1,

128 > NumExtensions: 0,

129 > NumServices: 0,

130 > },

131 > GoTypes: file_temporal_server_api_namespace_v1_message_proto_goTypes,

132 > DependencyIndexes: file_temporal_server_api_namespace_v1_message_proto_depIdxs,

133 > MessageInfos: file_temporal_server_api_namespace_v1_message_proto_msgTypes,

134 > }.Build()

135 > File_temporal_server_api_namespace_v1_message_proto = out.File

136 > file_temporal_server_api_namespace_v1_message_proto_goTypes = nil

137 > file_temporal_server_api_namespace_v1_message_proto_depIdxs = nil

138 }

go.temporal.io/server/api/persistence/v1/chasm_visibility.pb.go 20 covered LOC · 2 ranges

Open complete file

146 }

147

148 > func init() { file_temporal_server_api_persistence_v1_chasm_visibility_proto_init() } chasm_visibility.pb.go

149 > func file_temporal_server_api_persistence_v1_chasm_visibility_proto_init() {

150 > if File_temporal_server_api_persistence_v1_chasm_visibility_proto != nil {

151 return

152 }

153 > type x struct{} chasm_visibility.pb.go

154 > out := protoimpl.TypeBuilder{

155 > File: protoimpl.DescBuilder{

156 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

157 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_chasm_visibility_proto_rawDesc), len(file_temporal_server_api_persistence_v1_chasm_visibility_proto_rawDesc)),

158 > NumEnums: 0,

159 > NumMessages: 2,

160 > NumExtensions: 0,

161 > NumServices: 0,

162 > },

163 > GoTypes: file_temporal_server_api_persistence_v1_chasm_visibility_proto_goTypes,

164 > DependencyIndexes: file_temporal_server_api_persistence_v1_chasm_visibility_proto_depIdxs,

165 > MessageInfos: file_temporal_server_api_persistence_v1_chasm_visibility_proto_msgTypes,

166 > }.Build()

167 > File_temporal_server_api_persistence_v1_chasm_visibility_proto = out.File

168 > file_temporal_server_api_persistence_v1_chasm_visibility_proto_goTypes = nil

169 > file_temporal_server_api_persistence_v1_chasm_visibility_proto_depIdxs = nil

170 }

go.temporal.io/server/api/persistence/v1/cluster_metadata.pb.go 20 covered LOC · 2 ranges

Open complete file

289 }

290

291 > func init() { file_temporal_server_api_persistence_v1_cluster_metadata_proto_init() } cluster_metadata.pb.go

292 > func file_temporal_server_api_persistence_v1_cluster_metadata_proto_init() {

293 > if File_temporal_server_api_persistence_v1_cluster_metadata_proto != nil {

294 return

295 }

296 > type x struct{} cluster_metadata.pb.go

297 > out := protoimpl.TypeBuilder{

298 > File: protoimpl.DescBuilder{

299 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

300 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_cluster_metadata_proto_rawDesc), len(file_temporal_server_api_persistence_v1_cluster_metadata_proto_rawDesc)),

301 > NumEnums: 0,

302 > NumMessages: 5,

303 > NumExtensions: 0,

304 > NumServices: 0,

305 > },

306 > GoTypes: file_temporal_server_api_persistence_v1_cluster_metadata_proto_goTypes,

307 > DependencyIndexes: file_temporal_server_api_persistence_v1_cluster_metadata_proto_depIdxs,

308 > MessageInfos: file_temporal_server_api_persistence_v1_cluster_metadata_proto_msgTypes,

309 > }.Build()

310 > File_temporal_server_api_persistence_v1_cluster_metadata_proto = out.File

311 > file_temporal_server_api_persistence_v1_cluster_metadata_proto_goTypes = nil

312 > file_temporal_server_api_persistence_v1_cluster_metadata_proto_depIdxs = nil

313 }

go.temporal.io/server/api/persistence/v1/history_tree.pb.go 20 covered LOC · 2 ranges

Open complete file

274 }

275

276 > func init() { file_temporal_server_api_persistence_v1_history_tree_proto_init() } history_tree.pb.go

277 > func file_temporal_server_api_persistence_v1_history_tree_proto_init() {

278 > if File_temporal_server_api_persistence_v1_history_tree_proto != nil {

279 return

280 }

281 > type x struct{} history_tree.pb.go

282 > out := protoimpl.TypeBuilder{

283 > File: protoimpl.DescBuilder{

284 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

285 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_history_tree_proto_rawDesc), len(file_temporal_server_api_persistence_v1_history_tree_proto_rawDesc)),

286 > NumEnums: 0,

287 > NumMessages: 3,

288 > NumExtensions: 0,

289 > NumServices: 0,

290 > },

291 > GoTypes: file_temporal_server_api_persistence_v1_history_tree_proto_goTypes,

292 > DependencyIndexes: file_temporal_server_api_persistence_v1_history_tree_proto_depIdxs,

293 > MessageInfos: file_temporal_server_api_persistence_v1_history_tree_proto_msgTypes,

294 > }.Build()

295 > File_temporal_server_api_persistence_v1_history_tree_proto = out.File

296 > file_temporal_server_api_persistence_v1_history_tree_proto_goTypes = nil

297 > file_temporal_server_api_persistence_v1_history_tree_proto_depIdxs = nil

298 }

go.temporal.io/server/api/persistence/v1/namespaces.pb.go 20 covered LOC · 2 ranges

Open complete file

536 }

537

538 > func init() { file_temporal_server_api_persistence_v1_namespaces_proto_init() } namespaces.pb.go

539 > func file_temporal_server_api_persistence_v1_namespaces_proto_init() {

540 > if File_temporal_server_api_persistence_v1_namespaces_proto != nil {

541 return

542 }

543 > type x struct{} namespaces.pb.go

544 > out := protoimpl.TypeBuilder{

545 > File: protoimpl.DescBuilder{

546 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

547 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_namespaces_proto_rawDesc), len(file_temporal_server_api_persistence_v1_namespaces_proto_rawDesc)),

548 > NumEnums: 0,

549 > NumMessages: 8,

550 > NumExtensions: 0,

551 > NumServices: 0,

552 > },

553 > GoTypes: file_temporal_server_api_persistence_v1_namespaces_proto_goTypes,

554 > DependencyIndexes: file_temporal_server_api_persistence_v1_namespaces_proto_depIdxs,

555 > MessageInfos: file_temporal_server_api_persistence_v1_namespaces_proto_msgTypes,

556 > }.Build()

557 > File_temporal_server_api_persistence_v1_namespaces_proto = out.File

558 > file_temporal_server_api_persistence_v1_namespaces_proto_goTypes = nil

559 > file_temporal_server_api_persistence_v1_namespaces_proto_depIdxs = nil

560 }

go.temporal.io/server/api/persistence/v1/queue_metadata.pb.go 20 covered LOC · 2 ranges

Open complete file

105 }

106

107 > func init() { file_temporal_server_api_persistence_v1_queue_metadata_proto_init() } queue_metadata.pb.go

108 > func file_temporal_server_api_persistence_v1_queue_metadata_proto_init() {

109 > if File_temporal_server_api_persistence_v1_queue_metadata_proto != nil {

110 return

111 }

112 > type x struct{} queue_metadata.pb.go

113 > out := protoimpl.TypeBuilder{

114 > File: protoimpl.DescBuilder{

115 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

116 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_queue_metadata_proto_rawDesc), len(file_temporal_server_api_persistence_v1_queue_metadata_proto_rawDesc)),

117 > NumEnums: 0,

118 > NumMessages: 2,

119 > NumExtensions: 0,

120 > NumServices: 0,

121 > },

122 > GoTypes: file_temporal_server_api_persistence_v1_queue_metadata_proto_goTypes,

123 > DependencyIndexes: file_temporal_server_api_persistence_v1_queue_metadata_proto_depIdxs,

124 > MessageInfos: file_temporal_server_api_persistence_v1_queue_metadata_proto_msgTypes,

125 > }.Build()

126 > File_temporal_server_api_persistence_v1_queue_metadata_proto = out.File

127 > file_temporal_server_api_persistence_v1_queue_metadata_proto_goTypes = nil

128 > file_temporal_server_api_persistence_v1_queue_metadata_proto_depIdxs = nil

129 }

go.temporal.io/server/api/persistence/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

846 }

847

848 > func init() { file_temporal_server_api_persistence_v1_tasks_proto_init() } tasks.pb.go

849 > func file_temporal_server_api_persistence_v1_tasks_proto_init() {

850 > if File_temporal_server_api_persistence_v1_tasks_proto != nil {

851 return

852 }

853 > type x struct{} tasks.pb.go

854 > out := protoimpl.TypeBuilder{

855 > File: protoimpl.DescBuilder{

856 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

857 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_tasks_proto_rawDesc), len(file_temporal_server_api_persistence_v1_tasks_proto_rawDesc)),

858 > NumEnums: 0,

859 > NumMessages: 8,

860 > NumExtensions: 0,

861 > NumServices: 0,

862 > },

863 > GoTypes: file_temporal_server_api_persistence_v1_tasks_proto_goTypes,

864 > DependencyIndexes: file_temporal_server_api_persistence_v1_tasks_proto_depIdxs,

865 > MessageInfos: file_temporal_server_api_persistence_v1_tasks_proto_msgTypes,

866 > }.Build()

867 > File_temporal_server_api_persistence_v1_tasks_proto = out.File

868 > file_temporal_server_api_persistence_v1_tasks_proto_goTypes = nil

869 > file_temporal_server_api_persistence_v1_tasks_proto_depIdxs = nil

870 }

go.temporal.io/server/api/token/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

785 }

786

787 > func init() { file_temporal_server_api_token_v1_message_proto_init() } message.pb.go

788 > func file_temporal_server_api_token_v1_message_proto_init() {

789 > if File_temporal_server_api_token_v1_message_proto != nil {

790 return

791 }

792 > type x struct{} message.pb.go

793 > out := protoimpl.TypeBuilder{

794 > File: protoimpl.DescBuilder{

795 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

796 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_token_v1_message_proto_rawDesc), len(file_temporal_server_api_token_v1_message_proto_rawDesc)),

797 > NumEnums: 0,

798 > NumMessages: 7,

799 > NumExtensions: 0,

800 > NumServices: 0,

801 > },

802 > GoTypes: file_temporal_server_api_token_v1_message_proto_goTypes,

803 > DependencyIndexes: file_temporal_server_api_token_v1_message_proto_depIdxs,

804 > MessageInfos: file_temporal_server_api_token_v1_message_proto_msgTypes,

805 > }.Build()

806 > File_temporal_server_api_token_v1_message_proto = out.File

807 > file_temporal_server_api_token_v1_message_proto_goTypes = nil

808 > file_temporal_server_api_token_v1_message_proto_depIdxs = nil

809 }

go.temporal.io/server/api/visibilityservice/v1/request_response.pb.go 20 covered LOC · 2 ranges

Open complete file

402 }

403

404 > func init() { file_temporal_server_api_visibilityservice_v1_request_response_proto_init() } request_response.pb.go

405 > func file_temporal_server_api_visibilityservice_v1_request_response_proto_init() {

406 > if File_temporal_server_api_visibilityservice_v1_request_response_proto != nil {

407 return

408 }

409 > type x struct{} request_response.pb.go

410 > out := protoimpl.TypeBuilder{

411 > File: protoimpl.DescBuilder{

412 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

413 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_visibilityservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_visibilityservice_v1_request_response_proto_rawDesc)),

414 > NumEnums: 0,

415 > NumMessages: 5,

416 > NumExtensions: 0,

417 > NumServices: 0,

418 > },

419 > GoTypes: file_temporal_server_api_visibilityservice_v1_request_response_proto_goTypes,

420 > DependencyIndexes: file_temporal_server_api_visibilityservice_v1_request_response_proto_depIdxs,

421 > MessageInfos: file_temporal_server_api_visibilityservice_v1_request_response_proto_msgTypes,

422 > }.Build()

423 > File_temporal_server_api_visibilityservice_v1_request_response_proto = out.File

424 > file_temporal_server_api_visibilityservice_v1_request_response_proto_goTypes = nil

425 > file_temporal_server_api_visibilityservice_v1_request_response_proto_depIdxs = nil

426 }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

91 }

92

93 > func init() { file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() } service.pb.go

94 > func file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() {

95 > if File_temporal_server_chasm_lib_activity_proto_v1_service_proto != nil {

96 return

97 }

98 > file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() service.pb.go

99 > type x struct{}

100 > out := protoimpl.TypeBuilder{

101 > File: protoimpl.DescBuilder{

102 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

103 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc)),

104 > NumEnums: 0,

105 > NumMessages: 0,

106 > NumExtensions: 0,

107 > NumServices: 1,

108 > },

109 > GoTypes: file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes,

110 > DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs,

111 > }.Build()

112 > File_temporal_server_chasm_lib_activity_proto_v1_service_proto = out.File

113 > file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes = nil

114 > file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs = nil

115 }

go.temporal.io/server/chasm/lib/callback/gen/callbackpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

148 }

149

150 > func init() { file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() } tasks.pb.go

151 > func file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() {

152 > if File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto != nil {

153 return

154 }

155 > type x struct{} tasks.pb.go

156 > out := protoimpl.TypeBuilder{

157 > File: protoimpl.DescBuilder{

158 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

159 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc)),

160 > NumEnums: 0,

161 > NumMessages: 2,

162 > NumExtensions: 0,

163 > NumServices: 0,

164 > },

165 > GoTypes: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes,

166 > DependencyIndexes: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs,

167 > MessageInfos: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_msgTypes,

168 > }.Build()

169 > File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto = out.File

170 > file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes = nil

171 > file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs = nil

172 }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

71 }

72

73 > func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() } service.pb.go

74 > func file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() {

75 > if File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto != nil {

76 return

77 }

78 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init() service.pb.go

79 > type x struct{}

80 > out := protoimpl.TypeBuilder{

81 > File: protoimpl.DescBuilder{

82 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

83 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc)),

84 > NumEnums: 0,

85 > NumMessages: 0,

86 > NumExtensions: 0,

87 > NumServices: 1,

88 > },

89 > GoTypes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes,

90 > DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs,

91 > }.Build()

92 > File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto = out.File

93 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes = nil

94 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs = nil

95 }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

354 }

355

356 > func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() } tasks.pb.go

357 > func file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() {

358 > if File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto != nil {

359 return

360 }

361 > type x struct{} tasks.pb.go

362 > out := protoimpl.TypeBuilder{

363 > File: protoimpl.DescBuilder{

364 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

365 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc)),

366 > NumEnums: 0,

367 > NumMessages: 7,

368 > NumExtensions: 0,

369 > NumServices: 0,

370 > },

371 > GoTypes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes,

372 > DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs,

373 > MessageInfos: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_msgTypes,

374 > }.Build()

375 > File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto = out.File

376 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes = nil

377 > file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs = nil

378 }

go.temporal.io/server/chasm/lib/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/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/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/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/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/service/history/events/notifier.go 18 covered LOC · 1 range

Open complete file

81 versionHistories *historyspb.VersionHistories,

82 transitionHistory []*persistencespb.VersionedTransition,

83 > ) *Notification { notifier.go

84 >

85 > return &Notification{

86 > ID: definition.NewWorkflowKey(

87 > namespaceID,

88 > workflowExecution.GetWorkflowId(),

89 > workflowExecution.GetRunId(),

90 > ),

91 > LastFirstEventID: lastFirstEventID,

92 > LastFirstEventTxnID: lastFirstEventTxnID,

93 > NextEventID: nextEventID,

94 > PreviousStartedEventID: previousStartedEventID,

95 > WorkflowState: workflowState,

96 > WorkflowStatus: workflowStatus,

97 > VersionHistories: versionhistory.CopyVersionHistories(versionHistories),

98 > TransitionHistory: transitionhistory.CopyVersionedTransitions(transitionHistory),

99 > }

100 > }

101

102 func NewNotifier(

go.temporal.io/server/service/history/tasks/task_category_registry.go 18 covered LOC · 4 ranges

Open complete file

26 // each entry point that uses it. Essentially, get it from the dependency graph instead of calling this method, unless

27 // you're in a test.

28 > func NewDefaultTaskCategoryRegistry() *MutableTaskCategoryRegistry { task_category_registry.go

29 > return &MutableTaskCategoryRegistry{

30 > categories: map[int]Category{

31 > CategoryTransfer.ID(): CategoryTransfer,

32 > CategoryTimer.ID(): CategoryTimer,

33 > CategoryVisibility.ID(): CategoryVisibility,

34 > CategoryReplication.ID(): CategoryReplication,

35 > CategoryMemoryTimer.ID(): CategoryMemoryTimer,

36 > CategoryOutbound.ID(): CategoryOutbound,

37 > },

38 > }

39 > }

40

41 // AddCategory register a Category with the registry or panics if a Category with the same ID has already been

42 // registered.

43 > func (r *MutableTaskCategoryRegistry) AddCategory(c Category) { task_category_registry.go

44 > if category, ok := r.categories[c.id]; ok {

45 panic(fmt.Sprintf(

46 "category id: %v has already been defined as type %v and name %v",

51 }

52

53 > r.categories[c.id] = c task_category_registry.go

54 }

55

61

62 // GetCategories returns a deep copy of all registered Category objects from the registry.

63 > func (r *MutableTaskCategoryRegistry) GetCategories() map[int]Category { task_category_registry.go

64 > return maps.Clone(r.categories)

65 > }

go.temporal.io/server/common/definition/workflow_key.go 16 covered LOC · 4 ranges

Open complete file

19 workflowID string,

20 runID string,

21 > ) WorkflowKey { workflow_key.go

22 > return WorkflowKey{

23 > NamespaceID: namespaceID,

24 > WorkflowID: workflowID,

25 > RunID: runID,

26 > }

27 > }

28

29 > func (k *WorkflowKey) GetNamespaceID() string { workflow_key.go

30 > return k.NamespaceID

31 > }

32

33 > func (k *WorkflowKey) GetWorkflowID() string { workflow_key.go

34 > return k.WorkflowID

35 > }

36

37 > func (k *WorkflowKey) GetRunID() string { workflow_key.go

38 > return k.RunID

39 > }

40

41 func (k *WorkflowKey) String() string {

go.temporal.io/server/service/history/tasks/key.go 16 covered LOC · 5 ranges

Open complete file

28 )

29

30 > func NewImmediateKey(taskID int64) Key { key.go

31 > return Key{

32 > FireTime: DefaultFireTime,

33 > TaskID: taskID,

34 > }

35 > }

36

37 > func NewKey(fireTime time.Time, taskID int64) Key { key.go

38 > return Key{

39 > FireTime: fireTime,

40 > TaskID: taskID,

41 > }

42 > }

43

44 func ValidateKey(key Key) error {

54 }

55

56 > func (left Key) CompareTo(right Key) int { key.go

57 > if left.FireTime.Before(right.FireTime) {

58 > return -1 key.go

59 > } else if left.FireTime.After(right.FireTime) { key.go

60 return 1

61 }

go.temporal.io/server/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/persistence/transitionhistory/transition_history.go 15 covered LOC · 8 ranges

Open complete file

12 func CopyVersionedTransitions(

13 transitions []*persistencespb.VersionedTransition,

14 > ) []*persistencespb.VersionedTransition { transition_history.go

15 > if transitions == nil {

16 > return nil transition_history.go

17 > }

18 copied := make([]*persistencespb.VersionedTransition, len(transitions))

19 for i, t := range transitions {

34 func LastVersionedTransition(

35 transitions []*persistencespb.VersionedTransition,

36 > ) *persistencespb.VersionedTransition { transition_history.go

37 > if len(transitions) == 0 {

38 > // transition history is not enabled transition_history.go

39 > return nil

40 > }

41 return transitions[len(transitions)-1]

42 }

51 func Compare(

52 a, b *persistencespb.VersionedTransition,

53 > ) int { transition_history.go

54 > if a.GetNamespaceFailoverVersion() < b.GetNamespaceFailoverVersion() {

55 return -1

56 }

57 > if a.GetNamespaceFailoverVersion() > b.GetNamespaceFailoverVersion() { transition_history.go

58 return 1

59 }

60

61 > if a.GetTransitionCount() < b.GetTransitionCount() { transition_history.go

62 > return -1 transition_history.go

63 > }

64 if a.GetTransitionCount() > b.GetTransitionCount() {

65 return 1

go.temporal.io/server/common/persistence/versionhistory/version_history_item.go 15 covered LOC · 9 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

24 > func IsEqualVersionHistoryItem(item1 *historyspb.VersionHistoryItem, item2 *historyspb.VersionHistoryItem) bool { version_history_item.go

25 > return item1.EventId == item2.EventId && item1.Version == item2.Version

26 > }

27

28 // IsEqualVersionHistoryItems checks whether version history items are equal

40

41 // CompareVersionHistoryItem compares 2 version history items

42 > func CompareVersionHistoryItem(item1 *historyspb.VersionHistoryItem, item2 *historyspb.VersionHistoryItem) int { version_history_item.go

43 > if item1.Version < item2.Version {

44 return -1

45 }

46 > if item1.Version > item2.Version { version_history_item.go

47 return 1

48 }

49

50 // item1.Version == item2.Version

51 > if item1.EventId < item2.EventId { version_history_item.go

52 return -1

53 }

54 > if item1.EventId > item2.EventId { version_history_item.go

55 return 1

56 }

57 > return 0 version_history_item.go

58 }

go.temporal.io/server/common/persistence/visibility/store/sql/query_converter_util_legacy.go 15 covered LOC · 3 ranges

Open complete file

68 }

69

70 > func newColName(name string) *colName { query_converter_util_legacy.go

71 > return &colName{Name: name}

72 > }

73

74 func newSAColName(

77 fieldName string,

78 valueType enumspb.IndexedValueType,

79 > ) *saColName { query_converter_util_legacy.go

80 > return &saColName{

81 > dbColName: newColName(dbColName),

82 > alias: alias,

83 > fieldName: fieldName,

84 > valueType: valueType,

85 > }

86 > }

87

88 func newFuncExpr(name string, exprs ...sqlparser.Expr) *sqlparser.FuncExpr {

105 }

106

107 > func getMaxDatetimeValue() time.Time { query_converter_util_legacy.go

108 > t, _ := time.Parse(time.RFC3339, "9999-12-31T23:59:59Z")

109 > return t

110 > }

111

112 // formatComparisonExprStringForError formats comparison expression after

go.temporal.io/server/service/history/shard/handover_tracker.go 15 covered LOC · 3 ranges

Open complete file

63

64 // NewDefaultHandoverTrackerFactory returns a factory that creates the default OSS HandoverTracker.

65 > func NewDefaultHandoverTrackerFactory() HandoverTrackerFactory { handover_tracker.go

66 > return func(params HandoverTrackerParams) HandoverTracker {

67 > return &defaultHandoverTracker{ handover_tracker.go

68 > handoverNamespaces: make(map[namespace.Name]*namespaceHandOverInfo),

69 > clusterMetadata: params.ClusterMetadata,

70 > getMaxReplicationTaskID: params.GetMaxReplicationTaskID,

71 > errorByStateFn: params.ErrorByStateFn,

72 > notifyReplicationFn: params.NotifyReplicationFn,

73 > logger: params.Logger,

74 > }

75 > }

76 }

77

113 }

114

115 > func (t *defaultHandoverTracker) IsInHandover(namespaceName namespace.Name, workflowID string) bool { handover_tracker.go

116 > _, ok := t.handoverNamespaces[namespaceName]

117 > return ok

118 > }

119

120 func (t *defaultHandoverTracker) GetHandoverNamespaces() map[string]*historyservice.HandoverNamespaceInfo {

go.temporal.io/server/common/build/build.go 14 covered LOC · 2 ranges

Open complete file

27 )

28

29 > func init() { build.go

30 > buildInfo, ok := debug.ReadBuildInfo()

31 > if !ok {

32 return

33 }

34

35 > InfoData.Available = true build.go

36 > InfoData.GoVersion = buildInfo.GoVersion

37 >

38 > for _, setting := range buildInfo.Settings {

39 > switch setting.Key {

40 > case "GOARCH":

41 > InfoData.GoArch = setting.Value

42 > case "GOOS":

43 > InfoData.GoOs = setting.Value

44 > case "CGO_ENABLED":

45 > InfoData.CgoEnabled = setting.Value == "1"

46 case "vcs.revision":

47 InfoData.GitRevision = setting.Value

go.temporal.io/server/common/dynamicconfig/gradual_change.go 14 covered LOC · 3 ranges

Open complete file

25 // StaticGradualChange returns a GradualChange whose Value always returns def and whose When

26 // always returns a time in the past.

27 > func StaticGradualChange[T any](def T) GradualChange[T] { gradual_change.go

28 > return GradualChange[T]{New: def}

29 > }

30

31 // Value returns the value for the given key at the given time.

56 // of type GradualChange into a GradualChange.

57 // nolint:revive // cognitive-complexity // this looks complicated but each case is fairly simple

58 > func ConvertGradualChange[T any](def T) func(v any) (GradualChange[T], error) { gradual_change.go

59 > changeConverter := ConvertStructure(StaticGradualChange(def))

60 >

61 > // Call this once so that if it's going to panic, it panics at static init time.

62 > _, _ = changeConverter(nil)

63 >

64 > switch reflect.TypeFor[T]() {

65 > case reflect.TypeFor[bool]():

66 > return func(v any) (GradualChange[T], error) {

67 if b, err := convertBool(v); err == nil {

68 var change GradualChange[T]

72 return changeConverter(v)

73 }

74 > case reflect.TypeFor[int](): gradual_change.go

75 > return func(v any) (GradualChange[T], error) {

76 if i, err := convertInt(v); err == nil {

77 var change GradualChange[T]

go.temporal.io/server/service/history/workflow/workflow_task_state_machine.go 14 covered LOC · 4 ranges

Open complete file

53 ms *MutableStateImpl,

54 metricsHandler metrics.Handler,

55 > ) *workflowTaskStateMachine { workflow_task_state_machine.go

56 > return &workflowTaskStateMachine{

57 > ms: ms,

58 > metricsHandler: metricsHandler,

59 > }

60 > }

61

62 func (m *workflowTaskStateMachine) ApplyWorkflowTaskScheduledEvent(

1196 }

1197

1198 > func (m *workflowTaskStateMachine) HasStartedWorkflowTask() bool { workflow_task_state_machine.go

1199 > return m.ms.executionInfo.WorkflowTaskScheduledEventId != common.EmptyEventID &&

1200 > m.ms.executionInfo.WorkflowTaskStartedEventId != common.EmptyEventID

1201 > }

1202

1203 > func (m *workflowTaskStateMachine) GetStartedWorkflowTask() *historyi.WorkflowTaskInfo { workflow_task_state_machine.go

1204 > if !m.HasStartedWorkflowTask() {

1205 > return nil workflow_task_state_machine.go

1206 > }

1207

1208 workflowTask := m.getWorkflowTaskInfo()

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 12 covered LOC · 6 ranges

Open complete file

15 )

16

17 > func newNoopMetricsHandler() *noopMetricsHandler { return &noopMetricsHandler{} } noop_impl.go

18

19 // WithTags creates a new MetricProvder with provided []Tag

20 // Tags are merged with registered Tags from the source MetricsHandler

21 > func (n *noopMetricsHandler) WithTags(...Tag) Handler { noop_impl.go

22 > return n

23 > }

24

25 // Counter obtains a counter for the given name.

29

30 // Gauge obtains a gauge for the given name.

31 > func (*noopMetricsHandler) Gauge(string) GaugeIface { noop_impl.go

32 > return NoopGaugeMetricFunc

33 > }

34

35 // Timer obtains a timer for the given name.

36 > func (*noopMetricsHandler) Timer(string) TimerIface { noop_impl.go

37 > return NoopTimerMetricFunc

38 > }

39

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

54

55 var NoopCounterMetricFunc = CounterFunc(func(i int64, t ...Tag) {})

56 > var NoopGaugeMetricFunc = GaugeFunc(func(f float64, t ...Tag) {}) noop_impl.go

57 > var NoopTimerMetricFunc = TimerFunc(func(d time.Duration, t ...Tag) {}) noop_impl.go

58 var NoopHistogramMetricFunc = HistogramFunc(func(i int64, t ...Tag) {})

go.temporal.io/server/common/persistence/visibility/store/elasticsearch/visibility_store.go 12 covered LOC · 3 ranges

Open complete file

101 }

102

103 > defaultSorter = func() []elastic.Sorter { visibility_store.go

104 > ret := make([]elastic.Sorter, 0, len(defaultSorterFields))

105 > for _, item := range defaultSorterFields {

106 > fs := elastic.NewFieldSort(item.name)

107 > if item.desc {

108 > fs.Desc()

109 > }

110 > if item.missing_first {

111 > fs.Missing("_first")

112 > } else {

113 fs.Missing("_last")

114 }

115 > ret = append(ret, fs) visibility_store.go

116 }

117 > return ret visibility_store.go

118 }()

119

go.temporal.io/server/common/primitives/timestamp/duration.go 12 covered LOC · 4 ranges

Open complete file

26 }

27

28 > func DurationPtr(td time.Duration) *durationpb.Duration { duration.go

29 > return durationpb.New(td)

30 > }

31

32 func MinDurationPtr(d1 *durationpb.Duration, d2 *durationpb.Duration) *durationpb.Duration {

35 }

36

37 > func DurationFromSeconds(s int64) *durationpb.Duration { duration.go

38 > return durationMultipleOf(s, time.Second)

39 > }

40

41 func DurationFromMinutes(m int64) *durationpb.Duration {

47 }

48

49 > func DurationFromDays(d int32) *durationpb.Duration { duration.go

50 > return durationMultipleOf(int64(d), time.Hour*24)

51 > }

52

53 > func durationMultipleOf(amt int64, mult time.Duration) *durationpb.Duration { duration.go

54 > return DurationPtr(time.Duration(amt) * mult)

55 > }

56

57 // ValidateAndCapProtoDuration validates protobuf durations for two conditions:

go.temporal.io/server/common/metrics/grpc.go 11 covered LOC · 4 ranges

Open complete file

123

124 // getMetricsContext extracts metrics context from golang context.

125 > func getMetricsContext(ctx context.Context) *metricsContext { grpc.go

126 > metricsCtx := ctx.Value(metricsCtxKey)

127 > if metricsCtx == nil {

128 > return nil grpc.go

129 > }

130

131 return metricsCtx.(*metricsContext)

138

139 // ContextCounterAdd adds value to counter within metrics context.

140 > func ContextCounterAdd(ctx context.Context, name string, value int64) bool { grpc.go

141 > metricsCtx := getMetricsContext(ctx)

142 >

143 > if metricsCtx == nil {

144 > return false grpc.go

145 > }

146

147 metricsCtx.Lock()

go.temporal.io/server/common/util/util.go 11 covered LOC · 4 ranges

Open complete file

20

21 // MaxTime returns the latest of the given time.Time values.

22 > func MaxTime(first time.Time, rest ...time.Time) time.Time { util.go

23 > latest := first

24 > for _, t := range rest {

25 > if t.After(latest) {

26 > latest = t util.go

27 > }

28 }

29 > return latest util.go

30 }

31

68

69 // InverseMap creates the inverse map, ie., for a key-value map, it builds the value-key map.

70 > func InverseMap[M ~map[K]V, K, V comparable](m M) map[V]K { util.go

71 > if m == nil {

72 > return nil

73 > }

74 invm := make(map[V]K, len(m))

75 for k, v := range m {

go.temporal.io/server/service/history/tests/vars.go 11 covered LOC · 1 range

Open complete file

158 )

159

160 > func NewDynamicConfig() *configs.Config { vars.go

161 > dc := dynamicconfig.NewNoopCollection()

162 > config := configs.NewConfig(dc, 1)

163 > config.EnableActivityEagerExecution = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)

164 > config.NamespaceCacheRefreshInterval = dynamicconfig.GetDurationPropertyFn(time.Second)

165 > config.ReplicationEnableUpdateWithNewTaskMerge = dynamicconfig.GetBoolPropertyFn(true)

166 > config.EnableWorkflowIdReuseStartTimeValidation = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)

167 > config.EnableTransitionHistory = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)

168 > config.EnableChasm = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(false)

169 > return config

170 > }

go.temporal.io/server/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/contextutil/metadata.go 10 covered LOC · 4 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 {

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/common/archiver/archival_metadata.go 9 covered LOC · 1 range

Open complete file

127

128 // NewDisabledArchvialConfig returns an ArchivalConfig where archival is disabled for both the cluster and the namespace

129 > func NewDisabledArchvialConfig() ArchivalConfig { archival_metadata.go

130 > return &archivalConfig{

131 > staticClusterState: ArchivalDisabled,

132 > dynamicClusterState: nil,

133 > enableRead: nil,

134 > namespaceDefaultState: enumspb.ARCHIVAL_STATE_DISABLED,

135 > namespaceDefaultURI: "",

136 > }

137 > }

138

139 // NewEnabledArchivalConfig returns an ArchivalConfig where archival is enabled for both the cluster and the namespace

go.temporal.io/server/common/dynamicconfig/static_client.go 9 covered LOC · 4 ranges

Open complete file

10 )

11

12 > func (s StaticClient) GetValue(key Key) []ConstrainedValue { static_client.go

13 > if v, ok := s[key]; ok {

14 if cvs, ok := v.([]ConstrainedValue); ok {

15 return cvs

17 return []ConstrainedValue{{Value: v}}

18 }

19 > return nil static_client.go

20 }

21

22 // NewNoopClient returns a Client that has no keys (a Collection using it will always return

23 // default values).

24 > func NewNoopClient() Client { static_client.go

25 > return StaticClient(nil)

26 > }

27

28 // NewNoopCollection creates a new noop collection.

29 > func NewNoopCollection() *Collection { static_client.go

30 > return NewCollection(NewNoopClient(), log.NewNoopLogger())

31 > }

go.temporal.io/server/common/persistence/sql/sqlplugin/util.go 9 covered LOC · 2 ranges

Open complete file

5 )

6

7 > func appendPrefix(prefix string, fields []string) []string { util.go

8 > out := make([]string, len(fields))

9 > for i, field := range fields {

10 > out[i] = prefix + field

11 > }

12 > return out

13 }

14

15 > func BuildNamedPlaceholder(fields ...string) string { util.go

16 > return strings.Join(appendPrefix(":", fields), ", ")

17 > }

go.temporal.io/server/common/testing/testhooks/test_impl.go 9 covered LOC · 2 ranges

Open complete file

89 var keyCounter atomic.Int64

90

91 > func newKey[T any, S any]() Key[T, S] { test_impl.go

92 > var zero S

93 > var s ScopeType

94 > switch any(zero).(type) {

95 > case namespace.ID, namespace.Name:

96 > s = ScopeNamespace

97 > case global:

98 > s = ScopeGlobal

99 default:

100 panic("testhooks: unknown scope type")

101 }

102 > return Key[T, S]{id: keyCounter.Add(1), scopeType: s} test_impl.go

103 }

go.temporal.io/server/service/history/tasks/category.go 9 covered LOC · 3 ranges

Open complete file

96 }

97

98 > func (c Category) ID() int { category.go

99 > return c.id

100 > }

101

102 > func (c Category) Name() string { category.go

103 > return c.name

104 > }

105

106 > func (c Category) Type() CategoryType { category.go

107 > return c.cType

108 > }

109

110 func (c Category) MarshalText() (text []byte, err error) {

go.temporal.io/server/service/history/workflow/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 {

50 }

51

52 > func (*noopChasmTree) IsDirty() bool { noop_chasm_tree.go

53 > return false

54 > }

55

56 func (*noopChasmTree) Terminate(chasm.TerminateComponentRequest) error {

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/common/archiver/metadata_mock.go 8 covered LOC · 1 range

Open complete file

20 // NewMetadataMock returns a new MetadataMock which uses the provided controller to create a MockArchivalMetadata

21 // instance.

22 > func NewMetadataMock(controller *gomock.Controller) MetadataMock { metadata_mock.go

23 > m := &metadataMock{

24 > MockArchivalMetadata: NewMockArchivalMetadata(controller),

25 > defaultHistoryConfig: NewDisabledArchvialConfig(),

26 > defaultVisibilityConfig: NewDisabledArchvialConfig(),

27 > }

28 > return m

29 > }

30

31 // MetadataMockRecorder is a wrapper around a ArchivalMetadata mock recorder.

go.temporal.io/server/common/headers/caller_info.go 8 covered LOC · 1 range

Open complete file

156 func GetCallerInfo(

157 ctx context.Context,

158 > ) CallerInfo { caller_info.go

159 > values := GetValues(ctx, CallerNameHeaderName, CallerTypeHeaderName, CallOriginHeaderName)

160 > return CallerInfo{

161 > CallerName: values[0],

162 > CallerType: values[1],

163 > CallOrigin: values[2],

164 > }

165 > }

go.temporal.io/server/common/namespace/mutate.go 8 covered LOC · 2 ranges

Open complete file

8 type mutationFunc func(*Namespace)

9

10 > func (f mutationFunc) apply(ns *Namespace) { mutate.go

11 > f(ns)

12 > }

13

14 // WithActiveCluster assigns the active cluster to a Namespace during a Clone

43

44 // WithGlobalFlag sets whether or not this Namespace is global.

45 > func WithGlobalFlag(b bool) Mutation { mutate.go

46 > return mutationFunc(

47 > func(ns *Namespace) {

48 > ns.replicationResolver.SetGlobalFlag(b)

49 > })

50 }

51

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/visibility.go 8 covered LOC · 1 range

Open complete file

73 )

74

75 > func buildOnDuplicateKeyUpdate(fields ...string) string { visibility.go

76 > items := make([]string, len(fields))

77 > for i, field := range fields {

78 > // This line is to ensure that no update occurs (for any column) if the version is behind the saved version.

79 > items[i] = fmt.Sprintf("%v = IF(%v < VALUES(%v), VALUES(%v), %v)",

80 > field, sqlplugin.VersionColumnName, sqlplugin.VersionColumnName, field, field)

81 > }

82 > return fmt.Sprintf("ON DUPLICATE KEY UPDATE %s", strings.Join(items, ", "))

83 }

84

go.temporal.io/server/common/tasks/priority.go 8 covered LOC · 2 ranges

Open complete file

59 )

60

61 > func (p Priority) String() string { priority.go

62 > s, ok := PriorityName[p]

63 > if ok {

64 > return s

65 > }

66 return strconv.Itoa(int(p))

67 }

77 func getPriority(

78 class, subClass Priority,

79 > ) Priority { priority.go

80 > return class | subClass

81 > }

go.temporal.io/server/service/history/workflow/query_registry.go 8 covered LOC · 1 range

Open complete file

25 )

26

27 > func NewQueryRegistry() historyi.QueryRegistry { query_registry.go

28 > return &queryRegistryImpl{

29 > buffered: make(map[string]query),

30 > completed: make(map[string]query),

31 > unblocked: make(map[string]query),

32 > failed: make(map[string]query),

33 > }

34 > }

35

36 func (r *queryRegistryImpl) HasBufferedQuery() bool {

go.temporal.io/server/chasm/statemachine.go 7 covered LOC · 1 range

Open complete file

34 // The apply function is called after verifying the transition is possible but before setting the destination state,

35 // so it can inspect the current (source) state.

36 > func NewTransition[S comparable, SM StateMachine[S], E any](src []S, dst S, apply func(SM, MutableContext, E) error) Transition[S, SM, E] { statemachine.go

37 > return Transition[S, SM, E]{

38 > Sources: src,

39 > Destination: dst,

40 > apply: apply,

41 > }

42 > }

43

44 // Possible returns a boolean indicating whether the transition is possible for the current state.

go.temporal.io/server/common/dynamicconfig/registry.go 7 covered LOC · 3 ranges

Open complete file

17 )

18

19 > func register(s GenericSetting) { registry.go

20 > if globalRegistry.queried.Load() {

21 panic("dynamicconfig.New*Setting must only be called from static initializers")

22 }

23 > if globalRegistry.settings == nil { registry.go

24 > globalRegistry.settings = make(map[Key]GenericSetting)

25 > }

26 > if globalRegistry.settings[s.Key()] != nil {

27 // nolint:forbidigo // only called during static initialization

28 panic(fmt.Sprintf("duplicate registration of dynamic config key: %q", s.Key().String()))

29 }

30 > globalRegistry.settings[s.Key()] = s registry.go

31 }

32

go.temporal.io/server/common/membership/grpc_resolver.go 7 covered LOC · 2 ranges

Open complete file

53 )

54

55 > func init() { grpc_resolver.go

56 > // This must be called in init to avoid race conditions.

57 > resolver.Register(&globalGrpcBuilder)

58 > }

59

60 // Most code should not use this, this is only exposed for code that has to recognize and use a

80 }

81

82 > func (m *grpcBuilder) Scheme() string { grpc_resolver.go

83 > return grpcResolverScheme

84 > }

85

86 func (m *grpcBuilder) getServiceResolver(u *url.URL) (ServiceResolver, error) {

go.temporal.io/server/service/history/hsm/sm.go 7 covered LOC · 1 range

Open complete file

41 // NewTransition creates a new [Transition] from the given source states to a destination state for a given event.

42 // The apply function is called after verifying the transition is possible and setting the destination state.

43 > func NewTransition[S comparable, SM StateMachine[S], E any](src []S, dst S, apply func(SM, E) (TransitionOutput, error)) Transition[S, SM, E] { sm.go

44 > return Transition[S, SM, E]{

45 > Sources: src,

46 > Destination: dst,

47 > apply: apply,

48 > }

49 > }

50

51 // Possible returns a boolean indicating whether the transition is possible for the current state.

go.temporal.io/server/service/history/vclock/vclock.go 7 covered LOC · 1 range

Open complete file

10 shardID int32,

11 clock int64,

12 > ) *clockspb.VectorClock { vclock.go

13 > return &clockspb.VectorClock{

14 > ClusterId: clusterID,

15 > ShardId: shardID,

16 > Clock: clock,

17 > }

18 > }

19

20 func Comparable(

go.temporal.io/server/api/persistence/v1/executions.go-helpers.pb.go 6 covered LOC · 2 ranges

Open complete file

54

55 // Size returns the size of the object, in bytes, once serialized

56 > func (val *WorkflowExecutionInfo) Size() int { executions.go-helpers.pb.go

57 > return proto.Size(val)

58 > }

59

60 // Equal returns whether two WorkflowExecutionInfo values are equivalent by recursively

239

240 // Size returns the size of the object, in bytes, once serialized

241 > func (val *WorkflowExecutionState) Size() int { executions.go-helpers.pb.go

242 > return proto.Size(val)

243 > }

244

245 // Equal returns whether two WorkflowExecutionState values are equivalent by recursively

go.temporal.io/server/common/clock/time_source.go 6 covered LOC · 2 ranges

Open complete file

31

32 // NewRealTimeSource returns a timeSource that uses the real wall timeSource time.

33 > func NewRealTimeSource() RealTimeSource { time_source.go

34 > return RealTimeSource{}

35 > }

36

37 // Now returns the current time, with the location set to UTC.

38 > func (ts RealTimeSource) Now() time.Time { time_source.go

39 > return time.Now().UTC()

40 > }

41

42 // Since returns the time elapsed since t

go.temporal.io/server/common/headers/headers.go 6 covered LOC · 2 ranges

Open complete file

45 // GetValues returns header values for passed header names.

46 // It always returns slice of the same size as number of passed header names.

47 > func GetValues(ctx context.Context, headerNames ...string) []string { headers.go

48 > headerValues := make([]string, len(headerNames))

49 >

50 > for i, headerName := range headerNames {

51 > if values := metadata.ValueFromIncomingContext(ctx, headerName); len(values) > 0 {

52 headerValues[i] = values[0]

53 }

54 }

55

56 > return headerValues headers.go

57 }

58

go.temporal.io/server/common/log/lazy_logger.go 6 covered LOC · 1 range

Open complete file

19 )

20

21 > func NewLazyLogger(logger Logger, tagFn func() []tag.Tag) *lazyLogger { lazy_logger.go

22 > return &lazyLogger{

23 > logger: logger,

24 > tagFn: tagFn,

25 > }

26 > }

27

28 func (l *lazyLogger) Debug(msg string, tags ...tag.Tag) {

go.temporal.io/server/common/metrics/option.go 6 covered LOC · 2 ranges

Open complete file

10 type WithDescription string

11

12 > func (h WithDescription) apply(m *metricDefinition) { option.go

13 > m.description = string(h)

14 > }

15

16 // WithUnit sets the unit of a metric. See NewBytesHistogramDef for an example.

17 type WithUnit MetricUnit

18

19 > func (h WithUnit) apply(m *metricDefinition) { option.go

20 > m.unit = MetricUnit(h)

21 > }

go.temporal.io/server/common/persistence/data_interfaces.go 6 covered LOC · 3 ranges

Open complete file

1408 // UnixMilliseconds returns t as a Unix time, the number of milliseconds elapsed since January 1, 1970 UTC.

1409 // It should be used for all CQL timestamp.

1410 > func UnixMilliseconds(t time.Time) int64 { data_interfaces.go

1411 > // Handling zero time separately because UnixNano is undefined for zero times.

1412 > if t.IsZero() {

1413 return 0

1414 }

1415

1416 > unixNano := t.UnixNano() data_interfaces.go

1417 > if unixNano < 0 {

1418 // Time is before January 1, 1970 UTC

1419 return 0

1420 }

1421 > return unixNano / int64(time.Millisecond) data_interfaces.go

1422 }

1423

go.temporal.io/server/common/persistence/nosql/nosqlplugin/cassandra/translator/fixed_address_translator.go 6 covered LOC · 2 ranges

Open complete file

15 )

16

17 > func init() { fixed_address_translator.go

18 > RegisterTranslator(fixedTranslatorName, NewFixedAddressTranslatorPlugin())

19 > }

20

21 type FixedAddressTranslatorPlugin struct {

22 }

23

24 > func NewFixedAddressTranslatorPlugin() TranslatorPlugin { fixed_address_translator.go

25 > return &FixedAddressTranslatorPlugin{}

26 > }

27

28 // GetTranslator What gocql driver does is that it will connect to the first node in the list in configuration

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/plugin.go 6 covered LOC · 1 range

Open complete file

43 }

44

45 > func init() { plugin.go

46 > sql.RegisterPlugin(PluginName, &plugin{

47 > queryConverter: &queryConverter{},

48 > connPool: newConnPool(),

49 > })

50 > }

51

52 func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/common/rpc/context.go 6 covered LOC · 1 range

Open complete file

25

26 // CopyContextValues copies values in source Context to destination Context.

27 > func CopyContextValues(dst context.Context, src context.Context) context.Context { context.go

28 > return &valueCopyCtx{

29 > Context: dst,

30 > valueCtx: src,

31 > }

32 > }

33

34 // ResetContextTimeout creates new context with specified timeout and copies values from source Context.

go.temporal.io/server/service/history/configs/task.go 6 covered LOC · 1 range

Open complete file

26 func ConvertWeightsToDynamicConfigValue(

27 weights map[tasks.Priority]int,

28 > ) map[string]any { task.go

29 > weightsForDC := make(map[string]any)

30 > for priority, weight := range weights {

31 > weightsForDC[priority.String()] = weight

32 > }

33 > return weightsForDC

34 }

35

go.temporal.io/server/api/adminservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

33

34 // NewMockAdminServiceClient creates a new mock instance.

35 > func NewMockAdminServiceClient(ctrl *gomock.Controller) *MockAdminServiceClient { service_grpc.pb.mock.go

36 > mock := &MockAdminServiceClient{ctrl: ctrl}

37 > mock.recorder = &MockAdminServiceClientMockRecorder{mock}

38 > return mock

39 > }

40

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

go.temporal.io/server/api/historyservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

33

34 // NewMockHistoryServiceClient creates a new mock instance.

35 > func NewMockHistoryServiceClient(ctrl *gomock.Controller) *MockHistoryServiceClient { service_grpc.pb.mock.go

36 > mock := &MockHistoryServiceClient{ctrl: ctrl}

37 > mock.recorder = &MockHistoryServiceClientMockRecorder{mock}

38 > return mock

39 > }

40

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

go.temporal.io/server/api/matchingservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

32

33 // NewMockMatchingServiceClient creates a new mock instance.

34 > func NewMockMatchingServiceClient(ctrl *gomock.Controller) *MockMatchingServiceClient { service_grpc.pb.mock.go

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

36 > mock.recorder = &MockMatchingServiceClientMockRecorder{mock}

37 > return mock

38 > }

39

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

go.temporal.io/server/chasm/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/persistence/history_branch_util.go 5 covered LOC · 1 range

Open complete file

41 )

42

43 > func NewHistoryBranchUtil(serializer serialization.Serializer) *HistoryBranchUtilImpl { history_branch_util.go

44 > return &HistoryBranchUtilImpl{

45 > serializer: serializer,

46 > }

47 > }

48

49 func (u *HistoryBranchUtilImpl) NewHistoryBranch(

go.temporal.io/server/common/persistence/namespace_replication_queue_mock.go 5 covered LOC · 1 range

Open complete file

31

32 // NewMockNamespaceReplicationQueue creates a new mock instance.

33 > func NewMockNamespaceReplicationQueue(ctrl *gomock.Controller) *MockNamespaceReplicationQueue { namespace_replication_queue_mock.go

34 > mock := &MockNamespaceReplicationQueue{ctrl: ctrl}

35 > mock.recorder = &MockNamespaceReplicationQueueMockRecorder{mock}

36 > return mock

37 > }

38

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

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

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/plugin.go 5 covered LOC · 1 range

Open complete file

24 var _ sqlplugin.Plugin = (*plugin)(nil)

25

26 > func init() { plugin.go

27 > sql.RegisterPlugin(PluginName, &plugin{

28 > queryConverter: &queryConverter{},

29 > })

30 > }

31

32 func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/conn_pool.go 5 covered LOC · 1 range

Open complete file

23 }

24

25 > func newConnPool() *connPool { conn_pool.go

26 > return &connPool{

27 > pool: make(map[string]entry),

28 > }

29 > }

30

31 // Allocate allocates the shared database in the pool or returns already exists instance with the same DSN. If instance

go.temporal.io/server/common/persistence/visibility/manager/visibility_manager_mock.go 5 covered LOC · 1 range

Open complete file

32

33 // NewMockVisibilityManager creates a new mock instance.

34 > func NewMockVisibilityManager(ctrl *gomock.Controller) *MockVisibilityManager { visibility_manager_mock.go

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

36 > mock.recorder = &MockVisibilityManagerMockRecorder{mock}

37 > return mock

38 > }

39

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

go.temporal.io/server/common/persistence/visibility/store/elasticsearch/client/client_mock.go 5 covered LOC · 1 range

Open complete file

32

33 // NewMockClient creates a new mock instance.

34 > func NewMockClient(ctrl *gomock.Controller) *MockClient { client_mock.go

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

36 > mock.recorder = &MockClientMockRecorder{mock}

37 > return mock

38 > }

39

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

go.temporal.io/server/common/sdk/factory_mock.go 5 covered LOC · 1 range

Open complete file

31

32 // NewMockClientFactory creates a new mock instance.

33 > func NewMockClientFactory(ctrl *gomock.Controller) *MockClientFactory { factory_mock.go

34 > mock := &MockClientFactory{ctrl: ctrl}

35 > mock.recorder = &MockClientFactoryMockRecorder{mock}

36 > return mock

37 > }

38

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

go.temporal.io/server/common/searchattribute/mapper_mock.go 5 covered LOC · 1 range

Open complete file

84

85 // NewMockMapperProvider creates a new mock instance.

86 > func NewMockMapperProvider(ctrl *gomock.Controller) *MockMapperProvider { mapper_mock.go

87 > mock := &MockMapperProvider{ctrl: ctrl}

88 > mock.recorder = &MockMapperProviderMockRecorder{mock}

89 > return mock

90 > }

91

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

go.temporal.io/server/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

32

33 // NewMockWorkflowServiceClient creates a new mock instance.

34 > func NewMockWorkflowServiceClient(ctrl *gomock.Controller) *MockWorkflowServiceClient { service_grpc.pb.mock.go

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

36 > mock.recorder = &MockWorkflowServiceClientMockRecorder{mock}

37 > return mock

38 > }

39

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

go.temporal.io/server/service/history/events/events_cache_mock.go 5 covered LOC · 1 range

Open complete file

31

32 // NewMockCache creates a new mock instance.

33 > func NewMockCache(ctrl *gomock.Controller) *MockCache { events_cache_mock.go

34 > mock := &MockCache{ctrl: ctrl}

35 > mock.recorder = &MockCacheMockRecorder{mock}

36 > return mock

37 > }

38

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

go.temporal.io/server/service/history/interfaces/mutable_state_mock.go 5 covered LOC · 1 range

Open complete file

61

62 // NewMockMutableState creates a new mock instance.

63 > func NewMockMutableState(ctrl *gomock.Controller) *MockMutableState { mutable_state_mock.go

64 > mock := &MockMutableState{ctrl: ctrl}

65 > mock.recorder = &MockMutableStateMockRecorder{mock}

66 > return mock

67 > }

68

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

go.temporal.io/server/common/cache/size_getter.go 4 covered LOC · 2 ranges

Open complete file

14 )

15

16 > func getSize(value any) int { size_getter.go

17 > if v, ok := value.(SizeGetter); ok {

18 > return v.CacheSize() size_getter.go

19 > }

20 // if the object does not have a CacheSize() method, assume is count limit cache, which size should be 1

21 return 1

go.temporal.io/server/common/convert/convert.go 4 covered LOC · 2 ranges

Open complete file

71 func StringSliceToSet(

72 inputs []string,

73 > ) map[string]struct{} { convert.go

74 > outputs := make(map[string]struct{}, len(inputs))

75 > for _, item := range inputs {

76 outputs[item] = struct{}{}

77 }

78 > return outputs convert.go

79 }

go.temporal.io/server/common/log/with_logger.go 4 covered LOC · 2 ranges

Open complete file

14 // With returns Logger instance that prepend every log entry with tags. If logger implements

15 // WithLogger it is used, otherwise every log call will be intercepted.

16 > func With(logger Logger, tags ...tag.Tag) Logger { with_logger.go

17 > if wl, ok := logger.(WithLogger); ok {

18 > return wl.With(tags...) with_logger.go

19 > }

20 return newWithLogger(logger, tags...)

21 }

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/error_type.go 4 covered LOC · 2 ranges

Open complete file

3 import "go.temporal.io/api/serviceerror"

4

5 > func OperationPossiblySucceeded(err error) bool { error_type.go

6 > switch err.(type) {

7 case *CurrentWorkflowConditionFailedError,

8 *WorkflowConditionFailedError,

17 // Persistence failure that means that write was definitely not committed.

18 return false

19 > default: error_type.go

20 > return true

21 }

22 }

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

Open complete file

139 )

140

141 > func NewSerializer() Serializer { serializer.go

142 > return &serializerImpl{encodingType: encodingTypeFromEnv()}

143 > }

144

145 func (t *serializerImpl) EncodingType() enumspb.EncodingType {

go.temporal.io/server/common/persistence/sql/store.go 3 covered LOC · 2 ranges

Open complete file

19

20 // RegisterPlugin will register a SQL plugin

21 > func RegisterPlugin(pluginName string, plugin sqlplugin.Plugin) { store.go

22 > if _, ok := supportedPlugins[pluginName]; ok {

23 panic("plugin " + pluginName + " already registered")

24 }

25 > supportedPlugins[pluginName] = plugin store.go

26 }

27

go.temporal.io/server/common/softassert/softassert.go 3 covered LOC · 2 ranges

Open complete file

26 // Example:

27 // softassert.That(logger, object.state == "ready", "object is not ready")

28 > func That(logger log.Logger, condition bool, staticMessage string, tags ...tag.Tag) bool { softassert.go

29 > if !condition {

30 // By using the same prefix for all assertions, they can be reliably found in logs.

31 logger.Error("failed assertion: "+staticMessage, append([]tag.Tag{tag.FailedAssertion}, tags...)...)

32 }

33 > return condition softassert.go

34 }

35

go.temporal.io/server/common/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() {}