TestPollComponent_StaleState

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

  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/service/history/workflow/mutable_state_impl.go 319 covered LOC · 63 ranges

Open complete file

  298
  
  	runID string,
  
  299
  
  	startTime time.Time,
  
  300
  >
  ) *MutableStateImpl {
  
mutable_state_impl.go

  301
  >
  
  302
  >
  	namespaceName := namespaceEntry.Name().String()
  
  303
  >
  	logger = log.NewLazyLogger(logger, func() []tag.Tag {
  
  304
  
  		return []tag.Tag{
  
  305
  
  			tag.WorkflowNamespace(namespaceName),

  309
  
  	})
  
  310
  
  311
  >
  	s := &MutableStateImpl{
  
mutable_state_impl.go

  312
  >
  		updateActivityInfos:            make(map[int64]*persistencespb.ActivityInfo),
  
  313
  >
  		pendingActivityTimerHeartbeats: make(map[int64]time.Time),
  
  314
  >
  		pendingActivityInfoIDs:         make(map[int64]*persistencespb.ActivityInfo),
  
  315
  >
  		pendingActivityIDToEventID:     make(map[string]int64),
  
  316
  >
  		deleteActivityInfos:            make(map[int64]struct{}),
  
  317
  >
  		syncActivityTasks:              make(map[int64]struct{}),
  
  318
  >
  
  319
  >
  		pendingTimerInfoIDs:     make(map[string]*persistencespb.TimerInfo),
  
  320
  >
  		pendingTimerEventIDToID: make(map[int64]string),
  
  321
  >
  		updateTimerInfos:        make(map[string]*persistencespb.TimerInfo),
  
  322
  >
  		deleteTimerInfos:        make(map[string]struct{}),
  
  323
  >
  
  324
  >
  		updateChildExecutionInfos:    make(map[int64]*persistencespb.ChildExecutionInfo),
  
  325
  >
  		pendingChildExecutionInfoIDs: make(map[int64]*persistencespb.ChildExecutionInfo),
  
  326
  >
  		deleteChildExecutionInfos:    make(map[int64]struct{}),
  
  327
  >
  
  328
  >
  		updateRequestCancelInfos:    make(map[int64]*persistencespb.RequestCancelInfo),
  
  329
  >
  		pendingRequestCancelInfoIDs: make(map[int64]*persistencespb.RequestCancelInfo),
  
  330
  >
  		deleteRequestCancelInfos:    make(map[int64]struct{}),
  
  331
  >
  
  332
  >
  		updateSignalInfos:    make(map[int64]*persistencespb.SignalInfo),
  
  333
  >
  		pendingSignalInfoIDs: make(map[int64]*persistencespb.SignalInfo),
  
  334
  >
  		deleteSignalInfos:    make(map[int64]struct{}),
  
  335
  >
  
  336
  >
  		updateSignalRequestedIDs:  make(map[string]struct{}),
  
  337
  >
  		pendingSignalRequestedIDs: make(map[string]struct{}),
  
  338
  >
  		deleteSignalRequestedIDs:  make(map[string]struct{}),
  
  339
  >
  
  340
  >
  		// This field will be initialized with a real chasm tree at the end of this function
  
  341
  >
  		// when feature flag is enabled.
  
  342
  >
  		chasmTree: &noopChasmTree{},
  
  343
  >
  
  344
  >
  		approximateSize:              0,
  
  345
  >
  		chasmNodeSizes:               make(map[string]int),
  
  346
  >
  		totalTombstones:              0,
  
  347
  >
  		currentVersion:               namespaceEntry.FailoverVersion(workflowID),
  
  348
  >
  		bufferEventsInDB:             nil,
  
  349
  >
  		stateInDB:                    enumsspb.WORKFLOW_EXECUTION_STATE_VOID,
  
  350
  >
  		nextEventIDInDB:              common.FirstEventID,
  
  351
  >
  		dbRecordVersion:              1,
  
  352
  >
  		namespaceEntry:               namespaceEntry,
  
  353
  >
  		appliedEvents:                make(map[string]struct{}),
  
  354
  >
  		InsertTasks:                  make(map[tasks.Category][]tasks.Task),
  
  355
  >
  		BestEffortDeleteTasks:        make(map[tasks.Category][]tasks.Key),
  
  356
  >
  		transitionHistoryEnabled:     shard.GetConfig().EnableTransitionHistory(namespaceName),
  
  357
  >
  		visibilityUpdated:            false,
  
  358
  >
  		executionStateUpdated:        false,
  
  359
  >
  		workflowTaskUpdated:          false,
  
  360
  >
  		updateInfoUpdated:            make(map[string]struct{}),
  
  361
  >
  		timerInfosUserDataUpdated:    make(map[string]struct{}),
  
  362
  >
  		activityInfosUserDataUpdated: make(map[int64]struct{}),
  
  363
  >
  		reapplyEventsCandidate:       []*historypb.HistoryEvent{},
  
  364
  >
  
  365
  >
  		QueryRegistry: NewQueryRegistry(),
  
  366
  >
  
  367
  >
  		shard:            shard,
  
  368
  >
  		clusterMetadata:  shard.GetClusterMetadata(),
  
  369
  >
  		eventsCache:      eventsCache,
  
  370
  >
  		config:           shard.GetConfig(),
  
  371
  >
  		timeSource:       shard.GetTimeSource(),
  
  372
  >
  		logger:           logger,
  
  373
  >
  		metricsHandler:   shard.GetMetricsHandler().WithTags(metrics.OperationTag(metrics.WorkflowContextScope)),
  
  374
  >
  		endpointRegistry: shard.EndpointRegistry(),
  
  375
  >
  	}
  
  376
  >
  
  377
  >
  	s.executionInfo = &persistencespb.WorkflowExecutionInfo{
  
  378
  >
  		NamespaceId: namespaceEntry.ID().String(),
  
  379
  >
  		WorkflowId:  workflowID,
  
  380
  >
  
  381
  >
  		WorkflowTaskVersion:          common.EmptyVersion,
  
  382
  >
  		WorkflowTaskScheduledEventId: common.EmptyEventID,
  
  383
  >
  		WorkflowTaskStartedEventId:   common.EmptyEventID,
  
  384
  >
  		WorkflowTaskRequestId:        emptyUUID,
  
  385
  >
  		WorkflowTaskTimeout:          timestamp.DurationFromSeconds(0),
  
  386
  >
  		WorkflowTaskAttempt:          1,
  
  387
  >
  
  388
  >
  		LastCompletedWorkflowTaskStartedEventId: common.EmptyEventID,
  
  389
  >
  
  390
  >
  		StartTime:              timestamppb.New(startTime),
  
  391
  >
  		ExecutionTime:          timestamppb.New(startTime),
  
  392
  >
  		VersionHistories:       versionhistory.NewVersionHistories(&historyspb.VersionHistory{}),
  
  393
  >
  		ExecutionStats:         &persistencespb.ExecutionStats{HistorySize: 0},
  
  394
  >
  		SubStateMachinesByType: make(map[string]*persistencespb.StateMachineMap),
  
  395
  >
  	}
  
  396
  >
  	s.executionInfo.TaskGenerationShardClockTimestamp = shard.CurrentVectorClock().GetClock()
  
  397
  >
  	s.approximateSize += s.executionInfo.Size()
  
  398
  >
  
  399
  >
  	s.executionState = &persistencespb.WorkflowExecutionState{
  
  400
  >
  		RunId: runID,
  
  401
  >
  
  402
  >
  		State:      enumsspb.WORKFLOW_EXECUTION_STATE_CREATED,
  
  403
  >
  		Status:     enumspb.WORKFLOW_EXECUTION_STATUS_RUNNING,
  
  404
  >
  		StartTime:  timestamppb.New(startTime),
  
  405
  >
  		RequestIds: make(map[string]*persistencespb.RequestIDInfo),
  
  406
  >
  	}
  
  407
  >
  	s.approximateSize += s.executionState.Size()
  
  408
  >
  
  409
  >
  	s.hBuilder = historybuilder.New(
  
  410
  >
  		s.timeSource,
  
  411
  >
  		s.shard.GenerateTaskIDs,
  
  412
  >
  		s.currentVersion,
  
  413
  >
  		common.FirstEventID,
  
  414
  >
  		s.bufferEventsInDB,
  
  415
  >
  		s.metricsHandler,
  
  416
  >
  		s.config.MaximumEventBatchSizeInBytes,
  
  417
  >
  	)
  
  418
  >
  	s.taskGenerator = GetTaskGeneratorProvider().NewTaskGenerator(shard, s)
  
  419
  >
  	s.workflowTaskManager = newWorkflowTaskStateMachine(s, s.metricsHandler)
  
  420
  >
  
  421
  >
  	s.mustInitHSM()
  
  422
  >
  
  423
  >
  	// TODO@time-skipping: support time skipping for chasm
  
  424
  >
  	if s.config.EnableChasm(namespaceName) {
  
  425
  >
  		s.chasmTree = chasm.NewEmptyTree(
  
mutable_state_impl.go

  426
  >
  			shard.ChasmRegistry(),
  
  427
  >
  			shard.GetTimeSource(),
  
  428
  >
  			s,
  
  429
  >
  			chasm.DefaultPathEncoder,
  
  430
  >
  			logger,
  
  431
  >
  			shard.GetMetricsHandler().WithTags(metrics.NamespaceTag(namespaceName)),
  
  432
  >
  		)
  
  433
  >
  	}
  
  434
  
  435
  >
  	if s.executionInfo.GetTimeSkippingInfo() != nil {
  
mutable_state_impl.go

  436
  
  		s.wrapTimeSourceWithTimeSkipping()
  
  437
  
  	}
  
  438
  >
  	return s
  
mutable_state_impl.go

  439
  
  }
  
  440

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

  576
  >
  		mutableState.approximateSize += nodeSize
  
  577
  >
  		mutableState.chasmNodeSizes[key] = nodeSize
  
  578
  >
  	}
  
  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
  
mutable_state_impl.go

  583
  >
  		mutableState.chasmTree, err = chasm.NewTreeFromDB(
  
  584
  >
  			dbRecord.ChasmNodes,
  
  585
  >
  			shard.ChasmRegistry(),
  
  586
  >
  			shard.GetTimeSource(),
  
  587
  >
  			mutableState,
  
  588
  >
  			chasm.DefaultPathEncoder,
  
  589
  >
  			mutableState.logger, // this logger is tagged with execution key.
  
  590
  >
  			shard.GetMetricsHandler().WithTags(metrics.NamespaceTag(namespaceEntry.Name().String())),
  
  591
  >
  		)
  
  592
  >
  		if err != nil {
  
  593
  
  			return nil, err
  
  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)
  
mutable_state_impl.go

  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

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

  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 {

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

  1143
  >
  		lastVersionedTransition := ms.CurrentVersionedTransition()
  
  1144
  >
  		ms.currentVersion = lastVersionedTransition.NamespaceFailoverVersion
  
  1145
  >
  	} else {
  
mutable_state_impl.go

  1146
  
  		versionHistory, err := versionhistory.GetCurrentVersionHistory(ms.executionInfo.VersionHistories)
  
  1147
  
  		if err != nil {

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

  1292
  >
  		return lastVersionedTransition.NamespaceFailoverVersion, nil
  
  1293
  >
  	}
  
  1294
  
  1295
  
  	return ms.GetLastEventVersion()

  1492
  
  }
  
  1493
  
  1494
  >
  func (ms *MutableStateImpl) GetQueryRegistry() historyi.QueryRegistry {
  
mutable_state_impl.go

  1495
  >
  	return ms.QueryRegistry
  
  1496
  >
  }
  
  1497
  
  1498
  
  // VisitUpdates visits mutable state update entries, ordered by the ID of the history event pointed to by the mutable

  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 {

  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

  7360
  
  }
  
  7361
  
  7362
  >
  func (ms *MutableStateImpl) RemoveSpeculativeWorkflowTaskTimeoutTask() {
  
mutable_state_impl.go

  7363
  >
  	if ms.speculativeWorkflowTaskTimeoutTask != nil {
  
  7364
  
  		// Cancelling task prevents it from being submitted to scheduler in memoryScheduledQueue.
  
  7365
  
  		ms.speculativeWorkflowTaskTimeoutTask.Cancel()

  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

  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

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

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

  9591
  >
  	}
  
  9592
  
  }
  
  9593

go.temporal.io/server/common/dynamicconfig/setting_gen.go 292 covered LOC · 68 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}, {}}
  
  1048
  
  		return matchAndConvert(

  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/chasm/tree.go 218 covered LOC · 64 ranges

Open complete file

  270
  
  	logger log.Logger,
  
  271
  
  	metricsHandler metrics.Handler,
  
  272
  >
  ) (*Node, error) {
  
tree.go

  273
  >
  	if len(serializedNodes) == 0 {
  
  274
  
  		root := NewEmptyTree(registry, timeSource, backend, pathEncoder, logger, metricsHandler)
  
  275
  
  		// NewEmptyTree initializes the serializedNode to an empty component node,

  278
  
  	}
  
  279
  
  280
  >
  	root := newTreeHelper(registry, timeSource, backend, pathEncoder, logger, metricsHandler)
  
tree.go

  281
  >
  	for encodedPath, serializedNode := range serializedNodes {
  
  282
  >
  		nodePath, err := pathEncoder.Decode(encodedPath)
  
  283
  >
  		if err != nil {
  
  284
  
  			return nil, err
  
  285
  
  		}
  
  286
  >
  		root.setSerializedNode(nodePath, encodedPath, serializedNode)
  
tree.go

  287
  
  	}
  
  288
  
  289
  >
  	if err := newTreeInitSearchAttributesAndMemo(root, registry); err != nil {
  
tree.go

  290
  
  		return nil, err
  
  291
  
  	}
  
  292
  >
  	return root, nil
  
tree.go

  293
  
  }
  
  294

  301
  
  	logger log.Logger,
  
  302
  
  	metricsHandler metrics.Handler,
  
  303
  >
  ) *Node {
  
tree.go

  304
  >
  	root := newTreeHelper(registry, timeSource, backend, pathEncoder, logger, metricsHandler)
  
  305
  >
  
  306
  >
  	// If serializedNodes is empty, it means that this new tree.
  
  307
  >
  	// Initialize empty serializedNode.
  
  308
  >
  	root.initSerializedNode(fieldTypeComponent)
  
  309
  >
  	// Default to Workflow archetype as empty tree is created for workflow as well.
  
  310
  >
  	root.serializedNode.Metadata.GetComponentAttributes().TypeId = WorkflowArchetypeID
  
  311
  >
  	// Although both value and serializedNode.Data are nil, they are considered NOT synced
  
  312
  >
  	// because value has no type and serializedNode does.
  
  313
  >
  	// deserialize method should set value when called.
  
  314
  >
  	root.setValueState(valueStateNeedDeserialize)
  
  315
  >
  	return root
  
  316
  >
  }
  
  317
  
  318
  
  func newTreeHelper(

  323
  
  	logger log.Logger,
  
  324
  
  	metricsHandler metrics.Handler,
  
  325
  >
  ) *Node {
  
tree.go

  326
  >
  	base := &nodeBase{
  
  327
  >
  		registry:       registry,
  
  328
  >
  		timeSource:     timeSource,
  
  329
  >
  		backend:        backend,
  
  330
  >
  		pathEncoder:    pathEncoder,
  
  331
  >
  		logger:         logger,
  
  332
  >
  		metricsHandler: metricsHandler,
  
  333
  >
  
  334
  >
  		mutation: NodesMutation{
  
  335
  >
  			UpdatedNodes: make(map[string]*persistencespb.ChasmNode),
  
  336
  >
  			DeletedNodes: make(map[string]struct{}),
  
  337
  >
  		},
  
  338
  >
  		systemMutation: NodesMutation{
  
  339
  >
  			UpdatedNodes: make(map[string]*persistencespb.ChasmNode),
  
  340
  >
  			DeletedNodes: make(map[string]struct{}),
  
  341
  >
  		},
  
  342
  >
  		newTasks:               make(map[any][]taskWithAttributes),
  
  343
  >
  		immediatePureTasks:     make(map[any][]taskWithAttributes),
  
  344
  >
  		pendingRequestLinks:    make(map[any]map[string][]*commonpb.Link),
  
  345
  >
  		pendingUserMetadata:    make(map[any]*sdkpb.UserMetadata),
  
  346
  >
  		valueToNode:            make(map[any]*Node),
  
  347
  >
  		taskValueCache:         make(map[*commonpb.DataBlob]reflect.Value),
  
  348
  >
  		needsPointerResolution: false,
  
  349
  >
  	}
  
  350
  >
  
  351
  >
  	return newNode(base, nil, "")
  
  352
  >
  }
  
  353
  
  354
  
  func newTreeInitSearchAttributesAndMemo(
  
  355
  
  	root *Node,
  
  356
  
  	registry *Registry,
  
  357
  >
  ) error {
  
tree.go

  358
  >
  	immutableContext := NewContext(context.Background(), root)
  
  359
  >
  	rootComponent, err := root.Component(immutableContext, ComponentRef{})
  
  360
  >
  	if err != nil {
  
  361
  
  		return err
  
  362
  
  	}

  366
  
  	// and currentMemo will just never be used.
  
  367
  
  368
  >
  	if saProvider, ok := rootComponent.(VisibilitySearchAttributesProvider); ok {
  
tree.go

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

  370
  >
  		root.currentSA = searchAttributeKeyValuesToMap(saSlice)
  
  371
  >
  	}
  
  372
  >
  	if memoProvider, ok := rootComponent.(VisibilityMemoProvider); ok {
  
tree.go

  373
  >
  		root.currentMemo = proto.Clone(memoProvider.Memo(immutableContext))
  
tree.go

  374
  >
  	}
  
  375
  
  376
  >
  	return nil
  
tree.go

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

  380
  >
  	result := make(map[string]VisibilityValue, len(saSlice))
  
  381
  >
  	for _, sa := range saSlice {
  
  382
  >
  		result[sa.Field] = sa.Value
  
  383
  >
  	}
  
  384
  >
  	return result
  
  385
  
  }
  
  386

  400
  
  // If the node is a component or data node, the index from node value to node (valueToNode)
  
  401
  
  // is also updated.
  
  402
  >
  func (n *Node) setValue(value any) {
  
tree.go

  403
  >
  	if !n.isComponent() && !n.isData() {
  
  404
  
  		n.value = value
  
  405
  
  		return
  
  406
  
  	}
  
  407
  
  408
  >
  	if n.value != nil {
  
tree.go

  409
  
  		delete(n.valueToNode, n.value)
  
  410
  
  	}
  
  411
  
  412
  >
  	n.value = value
  
tree.go

  413
  >
  
  414
  >
  	if value != nil {
  
  415
  >
  		n.valueToNode[value] = n
  
  416
  >
  	}
  
  417
  
  }
  
  418
  
  419
  >
  func (n *Node) setValueState(state valueState) {
  
tree.go

  420
  >
  	n.valueState = state
  
  421
  >
  	if state >= valueStateNeedSerialize {
  
  422
  
  		n.markSubtreeDirty()
  
  423
  
  	}

  458
  
  	chasmContext Context,
  
  459
  
  	ref ComponentRef,
  
  460
  >
  ) (Component, error) {
  
tree.go

  461
  >
  	// Archetype is already validated before this method is called.
  
  462
  >
  	// (when the mutable state is loaded, in chasm engine implementation)
  
  463
  >
  
  464
  >
  	node, ok := n.findNode(ref.componentPath)
  
  465
  >
  	if !ok {
  
  466
  
  		return nil, errComponentNotFound
  
  467
  
  	}
  
  468
  
  469
  >
  	if ref.componentInitialVT != nil && transitionhistory.Compare(
  
tree.go

  470
  >
  		ref.componentInitialVT,
  
  471
  >
  		node.serializedNode.Metadata.InitialVersionedTransition,
  
  472
  >
  	) != 0 {
  
  473
  
  		return nil, errComponentNotFound
  
  474
  
  	}
  
  475
  
  476
  >
  	validationContext := NewContext(chasmContext.goContext(), node)
  
tree.go

  477
  >
  	if err := node.prepareComponentValue(validationContext); err != nil {
  
  478
  
  		return nil, err
  
  479
  
  	}
  
  480
  
  481
  >
  	componentValue, ok := node.value.(Component)
  
tree.go

  482
  >
  	if !ok {
  
  483
  
  		return nil, softassert.UnexpectedInternalErr(
  
  484
  
  			n.logger,

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

  490
  
  		return nil, err
  
  491
  
  	}
  
  492
  
  493
  >
  	if ref.validationFn != nil {
  
tree.go

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

  498
  
  499
  
  	// prepare component value again using incoming context to mark node as dirty if needed.
  
  500
  >
  	if err := node.prepareComponentValue(chasmContext); err != nil {
  
tree.go

  501
  
  		return nil, err
  
  502
  
  	}
  
  503
  >
  	return componentValue, nil
  
tree.go

  504
  
  }
  
  505

  517
  
  // Note: engine mutations on paused components are still accepted (checkPaused=false),
  
  518
  
  // per the current requirement.
  
  519
  >
  func (n *Node) validateAccess(ctx Context, checkPaused bool) error {
  
tree.go

  520
  >
  	intent := operationIntentFromContext(ctx.goContext())
  
  521
  >
  	if intent != OperationIntentProgress {
  
  522
  >
  		// Read-only operations are always allowed.
  
tree.go

  523
  >
  		return nil
  
  524
  >
  	}
  
  525
  
  526
  
  	// Detached nodes skip ancestor validation entirely.

  598
  
  func (n *Node) prepareComponentValue(
  
  599
  
  	chasmContext Context,
  
  600
  >
  ) error {
  
tree.go

  601
  >
  	if n.valueState == valueStateNeedDeserialize {
  
  602
  >
  		metadata := n.serializedNode.Metadata
  
tree.go

  603
  >
  		componentAttr := metadata.GetComponentAttributes()
  
  604
  >
  		if componentAttr == nil {
  
  605
  
  			return softassert.UnexpectedInternalErr(
  
  606
  
  				n.logger,

  609
  
  		}
  
  610
  
  611
  >
  		registrableComponent, ok := n.registry.ComponentByID(componentAttr.GetTypeId())
  
tree.go

  612
  >
  		if !ok {
  
  613
  
  			return softassert.UnexpectedInternalErr(
  
  614
  
  				n.logger,

  617
  
  		}
  
  618
  
  619
  >
  		if err := n.deserialize(registrableComponent.goType); err != nil {
  
tree.go

  620
  
  			return fmt.Errorf("failed to deserialize component: %w", err)
  
  621
  
  		}

  624
  
  	// For now, we assume if a node is accessed with a MutableContext,
  
  625
  
  	// its value will be mutated and no longer in sync with the serializedNode.
  
  626
  >
  	_, componentCanBeMutated := chasmContext.(MutableContext)
  
tree.go

  627
  >
  	if componentCanBeMutated {
  
  628
  
  		n.setValueState(valueStateNeedSyncStructure)
  
  629
  
  	}
  
  630
  
  631
  >
  	return nil
  
tree.go

  632
  
  }
  
  633

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

  683
  >
  	return n.serializedNode.GetMetadata().GetComponentAttributes() != nil
  
  684
  >
  }
  
  685
  
  686
  
  func (n *Node) isData() bool {

  733
  
  }
  
  734
  
  735
  >
  func assertStructPointer(t reflect.Type) error {
  
tree.go

  736
  >
  	if t == nil {
  
  737
  
  		return nil
  
  738
  
  	}
  
  739
  
  740
  >
  	if t.Kind() != reflect.Pointer || t.Elem().Kind() != reflect.Struct {
  
tree.go

  741
  
  		return serviceerror.NewInternalf("only pointer to struct is supported for tree node value: got %s", t.String())
  
  742
  
  	}
  
  743
  >
  	return nil
  
tree.go

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

  747
  >
  	switch ft {
  
  748
  
  	case fieldTypeData:
  
  749
  
  		n.serializedNode = &persistencespb.ChasmNode{

  758
  
  			},
  
  759
  
  		}
  
  760
  >
  	case fieldTypeComponent:
  
tree.go

  761
  >
  		n.serializedNode = &persistencespb.ChasmNode{
  
  762
  >
  			Metadata: &persistencespb.ChasmNodeMetadata{
  
  763
  >
  				InitialVersionedTransition: &persistencespb.VersionedTransition{
  
  764
  >
  					TransitionCount:          n.backend.NextTransitionCount(),
  
  765
  >
  					NamespaceFailoverVersion: n.backend.GetCurrentVersion(),
  
  766
  >
  				},
  
  767
  >
  				Attributes: &persistencespb.ChasmNodeMetadata_ComponentAttributes{
  
  768
  >
  					ComponentAttributes: &persistencespb.ChasmComponentAttributes{},
  
  769
  >
  				},
  
  770
  >
  			},
  
  771
  >
  		}
  
  772
  
  	case fieldTypePointer, fieldTypeDeferredPointer:
  
  773
  
  		// A deferred pointer will be resolved to a regular pointer before persistence.

  807
  
  	encodedPath string,
  
  808
  
  	serializedNode *persistencespb.ChasmNode,
  
  809
  >
  ) *Node {
  
tree.go

  810
  >
  	if len(nodePath) == 0 {
  
  811
  >
  		n.serializedNode = serializedNode
  
  812
  >
  		n.setValueState(valueStateNeedDeserialize)
  
  813
  >
  		n.encodedPath = &encodedPath
  
  814
  >
  		return n
  
  815
  >
  	}
  
  816
  
  817
  
  	childName := nodePath[0]

  1292
  
  func (n *Node) deserialize(
  
  1293
  
  	valueT reflect.Type,
  
  1294
  >
  ) error {
  
tree.go

  1295
  >
  	if err := assertStructPointer(valueT); err != nil {
  
  1296
  
  		return err
  
  1297
  
  	}
  
  1298
  
  1299
  >
  	if n.valueState != valueStateNeedDeserialize && reflect.TypeOf(n.value) == valueT {
  
tree.go

  1300
  
  		return nil
  
  1301
  
  	}
  
  1302
  
  1303
  >
  	switch n.serializedNode.GetMetadata().GetAttributes().(type) {
  
tree.go

  1304
  >
  	case *persistencespb.ChasmNodeMetadata_ComponentAttributes:
  
  1305
  >
  		return n.deserializeComponentNode(valueT)
  
  1306
  
  	case *persistencespb.ChasmNodeMetadata_DataAttributes:
  
  1307
  
  		return n.deserializeDataNode(valueT)

  1318
  
  func (n *Node) deserializeComponentNode(
  
  1319
  
  	valueT reflect.Type,
  
  1320
  >
  ) error {
  
tree.go

  1321
  >
  	// valueT is guaranteed to be a pointer to the struct because it was already validated by the assertStructPointer method.
  
  1322
  >
  	valueV := reflect.New(valueT.Elem())
  
  1323
  >
  
  1324
  >
  	for field := range fieldsOf(valueV) {
  
  1325
  >
  		if field.err != nil {
  
  1326
  
  			return field.err
  
  1327
  
  		}
  
  1328
  
  1329
  >
  		switch field.kind {
  
tree.go

  1330
  
  		case fieldKindUnspecified:
  
  1331
  
  			softassert.Fail(

  1333
  
  				"field.kind can be unspecified only if err is not nil, and there is a check for it above",
  
  1334
  
  				tag.String("node name", n.nodeName))
  
  1335
  >
  		case fieldKindData:
  
tree.go

  1336
  >
  			value, err := unmarshalProto(n.serializedNode.GetData(), field.typ)
  
  1337
  >
  			if err != nil {
  
  1338
  
  				return err
  
  1339
  
  			}
  
  1340
  >
  			field.val.Set(value)
  
tree.go

  1341
  
  		case fieldKindSubField:
  
  1342
  
  			if childNode, found := n.children[field.name]; found {

  1379
  
  	}
  
  1380
  
  1381
  >
  	n.setValue(valueV.Interface())
  
tree.go

  1382
  >
  	n.setValueState(valueStateSynced)
  
  1383
  >
  	return nil
  
  1384
  
  }
  
  1385

  1407
  
  	dataBlob *commonpb.DataBlob,
  
  1408
  
  	valueT reflect.Type,
  
  1409
  >
  ) (reflect.Value, error) {
  
tree.go

  1410
  >
  	if !valueT.AssignableTo(protoMessageT) {
  
  1411
  
  		return reflect.Value{}, serviceerror.NewInternal("only support proto.Message as chasm data")
  
  1412
  
  	}
  
  1413
  
  1414
  >
  	value := reflect.New(valueT.Elem())
  
tree.go

  1415
  >
  
  1416
  >
  	if dataBlob == nil || len(dataBlob.Data) == 0 {
  
  1417
  >
  		// If the original data is the zero value of its type, the dataBlob loaded from persistence layer will be nil.
  
tree.go

  1418
  >
  		// But we know for component & data nodes, they won't get persisted in the first place if there's no data,
  
  1419
  >
  		// so it must be a zero value.
  
  1420
  >
  		dataBlob = &commonpb.DataBlob{
  
  1421
  >
  			EncodingType: enumspb.ENCODING_TYPE_PROTO3,
  
  1422
  >
  			Data:         []byte{},
  
  1423
  >
  		}
  
  1424
  >
  	}
  
  1425
  
  1426
  >
  	if err := serialization.Decode(dataBlob, value.Interface().(proto.Message)); err != nil {
  
tree.go

  1427
  
  		return reflect.Value{}, err
  
  1428
  
  	}
  
  1429
  
  1430
  >
  	return value, nil
  
tree.go

  1431
  
  }
  
  1432

  1663
  
  func (n *Node) Now(
  
  1664
  
  	_ Component,
  
  1665
  >
  ) time.Time {
  
tree.go

  1666
  >
  	// TODO: Now() could be different for components after we support Pause for CHASM components.
  
  1667
  >
  	return n.timeSource.Now()
  
  1668
  >
  }
  
  1669
  
  1670
  
  // AddTask implements the CHASM MutableContext interface

  2952
  
  func (n *Node) findNode(
  
  2953
  
  	path []string,
  
  2954
  >
  ) (*Node, bool) {
  
tree.go

  2955
  >
  	if len(path) == 0 {
  
  2956
  >
  		return n, true
  
  2957
  >
  	}
  
  2958
  
  2959
  
  	childName := path[0]

  3042
  
  // and need to be persisted in DB.
  
  3043
  
  // The result will be reset to false after a call to CloseTransaction().
  
  3044
  >
  func (n *Node) IsDirty() bool {
  
tree.go

  3045
  >
  	if n.IsStateDirty() {
  
  3046
  
  		return true
  
  3047
  
  	}
  
  3048
  
  3049
  >
  	return len(n.systemMutation.UpdatedNodes) > 0 || len(n.systemMutation.DeletedNodes) > 0
  
tree.go

  3050
  
  }
  
  3051

  3053
  
  // which need to be persisted to DB AND replicated to other clusters.
  
  3054
  
  // The result will be reset to false after a call to CloseTransaction().
  
  3055
  >
  func (n *Node) IsStateDirty() bool {
  
tree.go

  3056
  >
  	return n.subtreeIsDirty ||
  
  3057
  >
  		len(n.mutation.UpdatedNodes) > 0 ||
  
  3058
  >
  		len(n.mutation.DeletedNodes) > 0
  
  3059
  >
  }
  
  3060
  
  3061
  
  func (n *Node) IsStale(
  
  3062
  
  	ref ComponentRef,
  
  3063
  >
  ) error {
  
tree.go

  3064
  >
  	// The point of this method to access the private executionLastUpdateVT field in componentRef,
  
  3065
  >
  	// and avoid exposing it in the public CHASM interface.
  
  3066
  >
  	if ref.executionLastUpdateVT == nil {
  
  3067
  
  		return nil
  
  3068
  
  	}
  
  3069
  
  3070
  >
  	return transitionhistory.StalenessCheck(
  
tree.go

  3071
  >
  		n.backend.GetExecutionInfo().TransitionHistory,
  
  3072
  >
  		ref.executionLastUpdateVT,
  
  3073
  >
  	)
  
  3074
  
  }
  
  3075

  3115
  
  3116
  
  // ArchetypeID returns the framework's internal ID for the root component's fully qualified name.
  
  3117
  >
  func (n *Node) ArchetypeID() ArchetypeID {
  
tree.go

  3118
  >
  	// Root must be a component.
  
  3119
  >
  	return n.root().serializedNode.Metadata.GetComponentAttributes().GetTypeId()
  
  3120
  >
  }
  
  3121
  
  3122
  
  // Archetype returns the root component's fully qualified name.

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

  3139
  >
  	if n.parent == nil {
  
  3140
  >
  		return n
  
  3141
  >
  	}
  
  3142
  
  	return n.parent.root()
  
  3143
  
  }

  3261
  
  	parent *Node,
  
  3262
  
  	nodeName string,
  
  3263
  >
  ) *Node {
  
tree.go

  3264
  >
  	return &Node{
  
  3265
  >
  		nodeBase: base,
  
  3266
  >
  		parent:   parent,
  
  3267
  >
  		children: make(map[string]*Node),
  
  3268
  >
  		nodeName: nodeName,
  
  3269
  >
  	}
  
  3270
  >
  }
  
  3271
  
  3272
  
  func compareSideEffectTasks(a, b *persistencespb.ChasmComponentAttributes_Task) int {

go.temporal.io/server/api/persistence/v1/executions.pb.go 137 covered LOC · 29 ranges

Open complete file

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

  86
  >
  	if x != nil {
  
  87
  >
  		return x.ShardId
  
  88
  >
  	}
  
  89
  
  	return 0
  
  90
  
  }

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

  100
  >
  	if x != nil {
  
  101
  >
  		return x.Owner
  
  102
  >
  	}
  
  103
  
  	return ""
  
  104
  
  }

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

  396
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[1]
  
  397
  >
  	if x != nil {
  
  398
  >
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
executions.pb.go

  399
  >
  		if ms.LoadMessageInfo() == nil {
  
  400
  >
  			ms.StoreMessageInfo(mi)
  
  401
  >
  		}
  
  402
  >
  		return ms
  
  403
  
  	}
  
  404
  
  	return mi.MessageOf(x)

  1142
  
  }
  
  1143
  
  1144
  >
  func (x *WorkflowExecutionInfo) GetTimeSkippingInfo() *TimeSkippingInfo {
  
executions.pb.go

  1145
  >
  	if x != nil {
  
  1146
  >
  		return x.TimeSkippingInfo
  
  1147
  >
  	}
  
  1148
  
  	return nil
  
  1149
  
  }

  1199
  
  func (*TimeSkippingInfo) ProtoMessage() {}
  
  1200
  
  1201
  >
  func (x *TimeSkippingInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  1202
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[2]
  
  1203
  >
  	if x != nil {
  
  1204
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1205
  
  		if ms.LoadMessageInfo() == nil {

  1208
  
  		return ms
  
  1209
  
  	}
  
  1210
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  1211
  
  }
  
  1212

  1333
  
  func (*LastNotifiedTargetVersion) ProtoMessage() {}
  
  1334
  
  1335
  >
  func (x *LastNotifiedTargetVersion) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  1336
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[4]
  
  1337
  >
  	if x != nil {
  
  1338
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1339
  
  		if ms.LoadMessageInfo() == nil {

  1342
  
  		return ms
  
  1343
  
  	}
  
  1344
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  1345
  
  }
  
  1346

  1390
  
  func (*ExecutionStats) ProtoMessage() {}
  
  1391
  
  1392
  >
  func (x *ExecutionStats) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  1393
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[5]
  
  1394
  >
  	if x != nil {
  
  1395
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1396
  
  		if ms.LoadMessageInfo() == nil {

  1399
  
  		return ms
  
  1400
  
  	}
  
  1401
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  1402
  
  }
  
  1403

  1463
  
  func (*WorkflowExecutionState) ProtoMessage() {}
  
  1464
  
  1465
  >
  func (x *WorkflowExecutionState) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  1466
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[6]
  
  1467
  >
  	if x != nil {
  
  1468
  >
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
executions.pb.go

  1469
  >
  		if ms.LoadMessageInfo() == nil {
  
  1470
  >
  			ms.StoreMessageInfo(mi)
  
  1471
  >
  		}
  
  1472
  >
  		return ms
  
  1473
  
  	}
  
  1474
  
  	return mi.MessageOf(x)

  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

  2876
  
  }
  
  2877
  
  2878
  >
  func (x *ActivityInfo) Reset() {
  
executions.pb.go

  2879
  >
  	*x = ActivityInfo{}
  
  2880
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[17]
  
  2881
  >
  	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  2882
  >
  	ms.StoreMessageInfo(mi)
  
  2883
  >
  }
  
  2884
  
  2885
  
  func (x *ActivityInfo) String() string {

  2889
  
  func (*ActivityInfo) ProtoMessage() {}
  
  2890
  
  2891
  >
  func (x *ActivityInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  2892
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[17]
  
  2893
  >
  	if x != nil {
  
  2894
  >
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
executions.pb.go

  2895
  >
  		if ms.LoadMessageInfo() == nil {
  
  2896
  >
  			ms.StoreMessageInfo(mi)
  
  2897
  >
  		}
  
  2898
  >
  		return ms
  
  2899
  
  	}
  
  2900
  
  	return mi.MessageOf(x)

  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

  4503
  
  func (*ActivityInfo_UseWorkflowBuildIdInfo) ProtoMessage() {}
  
  4504
  
  4505
  >
  func (x *ActivityInfo_UseWorkflowBuildIdInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  4506
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[39]
  
  4507
  >
  	if x != nil {
  
  4508
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  4509
  
  		if ms.LoadMessageInfo() == nil {

  4512
  
  		return ms
  
  4513
  
  	}
  
  4514
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  4515
  
  }
  
  4516

  4561
  
  func (*ActivityInfo_PauseInfo) ProtoMessage() {}
  
  4562
  
  4563
  >
  func (x *ActivityInfo_PauseInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  4564
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[40]
  
  4565
  >
  	if x != nil {
  
  4566
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  4567
  
  		if ms.LoadMessageInfo() == nil {

  4570
  
  		return ms
  
  4571
  
  	}
  
  4572
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  4573
  
  }
  
  4574

  5706
  
  }
  
  5707
  
  5708
  >
  func init() { file_temporal_server_api_persistence_v1_executions_proto_init() }
  
executions.pb.go

  5709
  >
  func file_temporal_server_api_persistence_v1_executions_proto_init() {
  
  5710
  >
  	if File_temporal_server_api_persistence_v1_executions_proto != nil {
  
  5711
  >
  		return
  
  5712
  >
  	}
  
  5713
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_init()
  
  5714
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_init()
  
  5715
  >
  	file_temporal_server_api_persistence_v1_queues_proto_init()
  
  5716
  >
  	file_temporal_server_api_persistence_v1_update_proto_init()
  
  5717
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[1].OneofWrappers = []any{
  
  5718
  >
  		(*WorkflowExecutionInfo_LastWorkflowTaskFailureCause)(nil),
  
  5719
  >
  		(*WorkflowExecutionInfo_LastWorkflowTaskTimedOutType)(nil),
  
  5720
  >
  	}
  
  5721
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[8].OneofWrappers = []any{
  
  5722
  >
  		(*TransferTaskInfo_CloseExecutionTaskDetails_)(nil),
  
  5723
  >
  		(*TransferTaskInfo_ChasmTaskInfo)(nil),
  
  5724
  >
  	}
  
  5725
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[10].OneofWrappers = []any{
  
  5726
  >
  		(*VisibilityTaskInfo_ChasmTaskInfo)(nil),
  
  5727
  >
  	}
  
  5728
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[11].OneofWrappers = []any{
  
  5729
  >
  		(*TimerTaskInfo_ChasmTaskInfo)(nil),
  
  5730
  >
  	}
  
  5731
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[13].OneofWrappers = []any{
  
  5732
  >
  		(*OutboundTaskInfo_StateMachineInfo)(nil),
  
  5733
  >
  		(*OutboundTaskInfo_ChasmTaskInfo)(nil),
  
  5734
  >
  		(*OutboundTaskInfo_WorkerCommandsTask)(nil),
  
  5735
  >
  	}
  
  5736
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[17].OneofWrappers = []any{
  
  5737
  >
  		(*ActivityInfo_UseWorkflowBuildIdInfo_)(nil),
  
  5738
  >
  		(*ActivityInfo_LastIndependentlyAssignedBuildId)(nil),
  
  5739
  >
  	}
  
  5740
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[23].OneofWrappers = []any{
  
  5741
  >
  		(*Callback_Nexus_)(nil),
  
  5742
  >
  		(*Callback_Hsm)(nil),
  
  5743
  >
  	}
  
  5744
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[40].OneofWrappers = []any{
  
  5745
  >
  		(*ActivityInfo_PauseInfo_Manual_)(nil),
  
  5746
  >
  		(*ActivityInfo_PauseInfo_RuleId)(nil),
  
  5747
  >
  	}
  
  5748
  >
  	file_temporal_server_api_persistence_v1_executions_proto_msgTypes[46].OneofWrappers = []any{
  
  5749
  >
  		(*CallbackInfo_Trigger_WorkflowClosed)(nil),
  
  5750
  >
  	}
  
  5751
  >
  	type x struct{}
  
  5752
  >
  	out := protoimpl.TypeBuilder{
  
  5753
  >
  		File: protoimpl.DescBuilder{
  
  5754
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  5755
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_executions_proto_rawDesc), len(file_temporal_server_api_persistence_v1_executions_proto_rawDesc)),
  
  5756
  >
  			NumEnums:      0,
  
  5757
  >
  			NumMessages:   47,
  
  5758
  >
  			NumExtensions: 0,
  
  5759
  >
  			NumServices:   0,
  
  5760
  >
  		},
  
  5761
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_executions_proto_goTypes,
  
  5762
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_executions_proto_depIdxs,
  
  5763
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_executions_proto_msgTypes,
  
  5764
  >
  	}.Build()
  
  5765
  >
  	File_temporal_server_api_persistence_v1_executions_proto = out.File
  
  5766
  >
  	file_temporal_server_api_persistence_v1_executions_proto_goTypes = nil
  
  5767
  >
  	file_temporal_server_api_persistence_v1_executions_proto_depIdxs = nil
  
  5768
  
  }

go.temporal.io/server/common/resourcetest/test_resource.go 132 covered LOC · 13 ranges

Open complete file

  95
  
  96
  
  // NewTest returns a new test resource instance
  
  97
  >
  func NewTest(controller *gomock.Controller, serviceName primitives.ServiceName) *Test {
  
test_resource.go

  98
  >
  	logger := log.NewTestLogger()
  
  99
  >
  
  100
  >
  	frontendClient := workflowservicemock.NewMockWorkflowServiceClient(controller)
  
  101
  >
  	matchingClient := matchingservicemock.NewMockMatchingServiceClient(controller)
  
  102
  >
  	historyClient := historyservicemock.NewMockHistoryServiceClient(controller)
  
  103
  >
  	remoteFrontendClient := workflowservicemock.NewMockWorkflowServiceClient(controller)
  
  104
  >
  	remoteAdminClient := adminservicemock.NewMockAdminServiceClient(controller)
  
  105
  >
  	clusterMetadataManager := persistence.NewMockClusterMetadataManager(controller)
  
  106
  >
  	clientBean := client.NewMockBean(controller)
  
  107
  >
  	clientBean.EXPECT().GetFrontendClient().Return(frontendClient).AnyTimes()
  
  108
  >
  	clientBean.EXPECT().GetMatchingClient(gomock.Any()).Return(matchingClient, nil).AnyTimes()
  
  109
  >
  	clientBean.EXPECT().GetHistoryClient().Return(historyClient).AnyTimes()
  
  110
  >
  	clientBean.EXPECT().GetRemoteAdminClient(gomock.Any()).Return(remoteAdminClient, nil).AnyTimes()
  
  111
  >
  	clientBean.EXPECT().GetRemoteFrontendClient(gomock.Any()).Return(nil, remoteFrontendClient, nil).AnyTimes()
  
  112
  >
  	clientFactory := client.NewMockFactory(controller)
  
  113
  >
  
  114
  >
  	metadataMgr := persistence.NewMockMetadataManager(controller)
  
  115
  >
  	taskMgr := persistence.NewMockTaskManager(controller)
  
  116
  >
  	shardMgr := persistence.NewMockShardManager(controller)
  
  117
  >
  	executionMgr := persistence.NewMockExecutionManager(controller)
  
  118
  >
  	executionMgr.EXPECT().GetHistoryBranchUtil().Return(persistence.NewHistoryBranchUtil(serialization.NewSerializer())).AnyTimes()
  
  119
  >
  	namespaceReplicationQueue := persistence.NewMockNamespaceReplicationQueue(controller)
  
  120
  >
  	nexusEndpointMgr := persistence.NewMockNexusEndpointManager(controller)
  
  121
  >
  
  122
  >
  	membershipMonitor := membership.NewMockMonitor(controller)
  
  123
  >
  	hostInfoProvider := membership.NewMockHostInfoProvider(controller)
  
  124
  >
  	frontendServiceResolver := membership.NewMockServiceResolver(controller)
  
  125
  >
  	matchingServiceResolver := membership.NewMockServiceResolver(controller)
  
  126
  >
  	historyServiceResolver := membership.NewMockServiceResolver(controller)
  
  127
  >
  	workerServiceResolver := membership.NewMockServiceResolver(controller)
  
  128
  >
  	membershipMonitor.EXPECT().GetResolver(primitives.FrontendService).Return(frontendServiceResolver, nil).AnyTimes()
  
  129
  >
  	membershipMonitor.EXPECT().GetResolver(primitives.InternalFrontendService).Return(nil, membership.ErrUnknownService).AnyTimes()
  
  130
  >
  	membershipMonitor.EXPECT().GetResolver(primitives.MatchingService).Return(matchingServiceResolver, nil).AnyTimes()
  
  131
  >
  	membershipMonitor.EXPECT().GetResolver(primitives.HistoryService).Return(historyServiceResolver, nil).AnyTimes()
  
  132
  >
  	membershipMonitor.EXPECT().GetResolver(primitives.WorkerService).Return(workerServiceResolver, nil).AnyTimes()
  
  133
  >
  	membershipMonitor.EXPECT().WaitUntilInitialized(gomock.Any()).Return(nil).AnyTimes()
  
  134
  >
  
  135
  >
  	scope := tally.NewTestScope("test", nil)
  
  136
  >
  	metricsHandler := metrics.NewTallyMetricsHandler(metrics.ClientConfig{}, scope).WithTags(
  
  137
  >
  		metrics.ServiceNameTag(serviceName),
  
  138
  >
  	)
  
  139
  >
  
  140
  >
  	return &Test{
  
  141
  >
  		MetricsScope:                   scope,
  
  142
  >
  		ClusterMetadata:                cluster.NewMockMetadata(controller),
  
  143
  >
  		SearchAttributesProvider:       searchattribute.NewMockProvider(controller),
  
  144
  >
  		SearchAttributesManager:        searchattribute.NewMockManager(controller),
  
  145
  >
  		SearchAttributesMapperProvider: searchattribute.NewMockMapperProvider(controller),
  
  146
  >
  
  147
  >
  		// other common resources
  
  148
  >
  
  149
  >
  		NamespaceCache:    namespace.NewMockRegistry(controller),
  
  150
  >
  		TimeSource:        clock.NewRealTimeSource(),
  
  151
  >
  		PayloadSerializer: serialization.NewSerializer(),
  
  152
  >
  		MetricsHandler:    metricsHandler,
  
  153
  >
  		ArchivalMetadata:  archiver.NewMetadataMock(controller),
  
  154
  >
  		ArchiverProvider:  provider.NewMockArchiverProvider(controller),
  
  155
  >
  
  156
  >
  		// membership infos
  
  157
  >
  
  158
  >
  		MembershipMonitor:       membershipMonitor,
  
  159
  >
  		HostInfoProvider:        hostInfoProvider,
  
  160
  >
  		FrontendServiceResolver: frontendServiceResolver,
  
  161
  >
  		MatchingServiceResolver: matchingServiceResolver,
  
  162
  >
  		HistoryServiceResolver:  historyServiceResolver,
  
  163
  >
  		WorkerServiceResolver:   workerServiceResolver,
  
  164
  >
  
  165
  >
  		// internal services clients
  
  166
  >
  
  167
  >
  		SDKClientFactory:     sdk.NewMockClientFactory(controller),
  
  168
  >
  		FrontendClient:       frontendClient,
  
  169
  >
  		MatchingClient:       matchingClient,
  
  170
  >
  		HistoryClient:        historyClient,
  
  171
  >
  		RemoteAdminClient:    remoteAdminClient,
  
  172
  >
  		RemoteFrontendClient: remoteFrontendClient,
  
  173
  >
  		ClientBean:           clientBean,
  
  174
  >
  		ClientFactory:        clientFactory,
  
  175
  >
  		ESClient:             esclient.NewMockClient(controller),
  
  176
  >
  		VisibilityManager:    manager.NewMockVisibilityManager(controller),
  
  177
  >
  
  178
  >
  		// persistence clients
  
  179
  >
  
  180
  >
  		MetadataMgr:               metadataMgr,
  
  181
  >
  		ClusterMetadataMgr:        clusterMetadataManager,
  
  182
  >
  		TaskMgr:                   taskMgr,
  
  183
  >
  		NamespaceReplicationQueue: namespaceReplicationQueue,
  
  184
  >
  		ShardMgr:                  shardMgr,
  
  185
  >
  		ExecutionMgr:              executionMgr,
  
  186
  >
  		NexusEndpointManager:      nexusEndpointMgr,
  
  187
  >
  
  188
  >
  		// logger
  
  189
  >
  
  190
  >
  		Logger: logger,
  
  191
  >
  	}
  
  192
  >
  }
  
  193
  
  194
  
  // Start for testing

  218
  
  219
  
  // GetClusterMetadata for testing
  
  220
  >
  func (t *Test) GetClusterMetadata() cluster.Metadata {
  
test_resource.go

  221
  >
  	return t.ClusterMetadata
  
  222
  >
  }
  
  223
  
  224
  
  // GetClusterMetadata for testing

  230
  
  231
  
  // GetNamespaceRegistry for testing
  
  232
  >
  func (t *Test) GetNamespaceRegistry() namespace.Registry {
  
test_resource.go

  233
  >
  	return t.NamespaceCache
  
  234
  >
  }
  
  235
  
  236
  
  // GetTimeSource for testing

  240
  
  241
  
  // GetPayloadSerializer for testing
  
  242
  >
  func (t *Test) GetPayloadSerializer() serialization.Serializer {
  
test_resource.go

  243
  >
  	return t.PayloadSerializer
  
  244
  >
  }
  
  245
  
  246
  
  // GetMetricsHandler for testing

  250
  
  251
  
  // GetArchivalMetadata for testing
  
  252
  >
  func (t *Test) GetArchivalMetadata() archiver.ArchivalMetadata {
  
test_resource.go

  253
  >
  	return t.ArchivalMetadata
  
  254
  >
  }
  
  255
  
  256
  
  // GetArchiverProvider for testing

  267
  
  268
  
  // GetHostInfoProvider for testing
  
  269
  >
  func (t *Test) GetHostInfoProvider() membership.HostInfoProvider {
  
test_resource.go

  270
  >
  	return t.HostInfoProvider
  
  271
  >
  }
  
  272
  
  273
  
  // GetFrontendServiceResolver for testing

  319
  
  320
  
  // GetHistoryClient for testing
  
  321
  >
  func (t *Test) GetHistoryClient() historyservice.HistoryServiceClient {
  
test_resource.go

  322
  >
  	return t.HistoryClient
  
  323
  >
  }
  
  324
  
  325
  
  // GetRemoteAdminClient for testing

  338
  
  339
  
  // GetClientBean for testing
  
  340
  >
  func (t *Test) GetClientBean() client.Bean {
  
test_resource.go

  341
  >
  	return t.ClientBean
  
  342
  >
  }
  
  343
  
  344
  
  // GetClientFactory for testing

  371
  
  372
  
  // GetShardManager for testing
  
  373
  >
  func (t *Test) GetShardManager() persistence.ShardManager {
  
test_resource.go

  374
  >
  	return t.ShardMgr
  
  375
  >
  }
  
  376
  
  377
  
  // GetExecutionManager for testing

  383
  
  384
  
  // GetLogger for testing
  
  385
  >
  func (t *Test) GetLogger() log.Logger {
  
test_resource.go

  386
  >
  	return t.Logger
  
  387
  >
  }
  
  388
  
  389
  
  // GetThrottledLogger for testing
  
  390
  >
  func (t *Test) GetThrottledLogger() log.Logger {
  
test_resource.go

  391
  >
  	return t.Logger
  
  392
  >
  }
  
  393
  
  394
  
  // GetGRPCListener for testing

  397
  
  }
  
  398
  
  399
  >
  func (t *Test) GetSearchAttributesProvider() searchattribute.Provider {
  
test_resource.go

  400
  >
  	return t.SearchAttributesProvider
  
  401
  >
  }
  
  402
  
  403
  
  func (t *Test) GetSearchAttributesManager() searchattribute.Manager {

  405
  
  }
  
  406
  
  407
  >
  func (t *Test) GetSearchAttributesMapperProvider() searchattribute.MapperProvider {
  
test_resource.go

  408
  >
  	return t.SearchAttributesMapperProvider
  
  409
  >
  }

go.temporal.io/server/common/metrics/tally_metrics_handler.go 123 covered LOC · 35 ranges

Open complete file

  37
  
  }
  
  38
  
  39
  >
  func newSharedScopeCache(maxSize int) *sharedScopeCache {
  
tally_metrics_handler.go

  40
  >
  	return &sharedScopeCache{
  
  41
  >
  		maxSize:  maxSize,
  
  42
  >
  		scopes:   make(map[string]tally.Scope),
  
  43
  >
  		handlers: make(map[string]*tallyMetricsHandler),
  
  44
  >
  	}
  
  45
  >
  }
  
  46
  
  47
  
  func (c *sharedScopeCache) loadOrStoreScope(key string, create func() tally.Scope) tally.Scope {

  68
  
  }
  
  69
  
  70
  >
  func (c *sharedScopeCache) loadOrStoreHandler(key string, create func() *tallyMetricsHandler) *tallyMetricsHandler {
  
tally_metrics_handler.go

  71
  >
  	c.mu.RLock()
  
  72
  >
  	if h, ok := c.handlers[key]; ok {
  
  73
  >
  		c.mu.RUnlock()
  
tally_metrics_handler.go

  74
  >
  		return h
  
  75
  >
  	}
  
  76
  >
  	c.mu.RUnlock()
  
tally_metrics_handler.go

  77
  >
  
  78
  >
  	h := create()
  
  79
  >
  
  80
  >
  	c.mu.Lock()
  
  81
  >
  	defer c.mu.Unlock()
  
  82
  >
  	// Double-check: another goroutine may have inserted while we were creating.
  
  83
  >
  	if existing, ok := c.handlers[key]; ok {
  
  84
  
  		return existing
  
  85
  
  	}
  
  86
  >
  	if len(c.handlers) >= c.maxSize {
  
tally_metrics_handler.go

  87
  
  		clear(c.handlers)
  
  88
  
  	}
  
  89
  >
  	c.handlers[key] = h
  
tally_metrics_handler.go

  90
  >
  	return h
  
  91
  
  }
  
  92

  109
  
  var _ Handler = (*tallyMetricsHandler)(nil)
  
  110
  
  111
  >
  func NewTallyMetricsHandler(cfg ClientConfig, scope tally.Scope) *tallyMetricsHandler {
  
tally_metrics_handler.go

  112
  >
  	perUnitBuckets := make(map[MetricUnit]tally.Buckets)
  
  113
  >
  
  114
  >
  	for unit, boundariesList := range cfg.PerUnitHistogramBoundaries {
  
  115
  
  		perUnitBuckets[MetricUnit(unit)] = tally.ValueBuckets(boundariesList)
  
  116
  
  	}
  
  117
  
  118
  >
  	maxSize := cfg.TagsCacheMaxSize
  
tally_metrics_handler.go

  119
  >
  	if maxSize <= 0 {
  
  120
  >
  		maxSize = defaultTagsCacheMaxSize
  
tally_metrics_handler.go

  121
  >
  	}
  
  122
  
  123
  >
  	return &tallyMetricsHandler{
  
tally_metrics_handler.go

  124
  >
  		scope:          scope,
  
  125
  >
  		perUnitBuckets: perUnitBuckets,
  
  126
  >
  		excludeTags:    configExcludeTags(cfg),
  
  127
  >
  		cache:          newSharedScopeCache(maxSize),
  
  128
  >
  		scopeKey:       "",
  
  129
  >
  	}
  
  130
  
  }
  
  131
  
  132
  
  // tagsCacheKey builds a compact string key from a tag slice for use as a
  
  133
  
  // map lookup key.
  
  134
  >
  func tagsCacheKey(tags []Tag) string {
  
tally_metrics_handler.go

  135
  >
  	size := 0
  
  136
  >
  	for i := range tags {
  
  137
  >
  		size += len(tags[i].Key) + len(tags[i].Value) + 2*binary.MaxVarintLen64
  
  138
  >
  	}
  
  139
  >
  	var sb strings.Builder
  
  140
  >
  	sb.Grow(size)
  
  141
  >
  	for _, t := range tags {
  
  142
  >
  		appendCacheKeyPart(&sb, t.Key)
  
  143
  >
  		appendCacheKeyPart(&sb, t.Value)
  
  144
  >
  	}
  
  145
  >
  	return sb.String()
  
  146
  
  }
  
  147
  
  148
  >
  func appendCacheKeyPart(sb *strings.Builder, value string) {
  
tally_metrics_handler.go

  149
  >
  	var lenBuf [binary.MaxVarintLen64]byte
  
  150
  >
  	n := binary.PutUvarint(lenBuf[:], uint64(len(value)))
  
  151
  >
  	_, _ = sb.Write(lenBuf[:n])
  
  152
  >
  	sb.WriteString(value)
  
  153
  >
  }
  
  154
  
  155
  
  // WithTags creates a new MetricProvider with provided []Tag
  
  156
  
  // Tags are merged with registered Tags from the source MetricsHandler.
  
  157
  
  // Handlers are cached by tag combination so repeated calls avoid allocations.
  
  158
  >
  func (tmh *tallyMetricsHandler) WithTags(tags ...Tag) Handler {
  
tally_metrics_handler.go

  159
  >
  	if len(tags) == 0 {
  
  160
  
  		return tmh
  
  161
  
  	}
  
  162
  >
  	normalizedKey := tagsCacheKey(normalizeTagsForCaching(tags, tmh.excludeTags))
  
tally_metrics_handler.go

  163
  >
  	key := tmh.scopeKey + normalizedKey
  
  164
  >
  	return tmh.cache.loadOrStoreHandler(key, func() *tallyMetricsHandler {
  
  165
  >
  		return &tallyMetricsHandler{
  
  166
  >
  			scope:          tmh.scope.Tagged(tagsToMap(tags, tmh.excludeTags)),
  
  167
  >
  			perUnitBuckets: tmh.perUnitBuckets,
  
  168
  >
  			excludeTags:    tmh.excludeTags,
  
  169
  >
  			cache:          tmh.cache,
  
  170
  >
  			scopeKey:       key,
  
  171
  >
  		}
  
  172
  >
  	})
  
  173
  
  }
  
  174

  178
  
  // excludeTags before cache key computation so that different raw values which
  
  179
  
  // map to the same excluded placeholder share a single cache entry.
  
  180
  >
  func (tmh *tallyMetricsHandler) cachedTaggedScope(tags []Tag) tally.Scope {
  
tally_metrics_handler.go

  181
  >
  	if len(tags) == 0 {
  
  182
  >
  		return tmh.scope
  
tally_metrics_handler.go

  183
  >
  	}
  
  184
  
  	key := tmh.scopeKey + tagsCacheKey(normalizeTagsForCaching(tags, tmh.excludeTags))
  
  185
  
  	return tmh.cache.loadOrStoreScope(key, func() tally.Scope {

  190
  
  // normalizeTag applies excludeTags substitution to a single tag.
  
  191
  
  // Returns the (possibly modified) tag and whether it was normalized.
  
  192
  >
  func normalizeTag(t Tag, excl excludeTags) (Tag, bool) {
  
tally_metrics_handler.go

  193
  >
  	if vals, ok := excl[t.Key]; ok {
  
  194
  
  		if _, ok := vals[t.Value]; !ok {
  
  195
  
  			return Tag{Key: t.Key, Value: tagExcludedValue}, true
  
  196
  
  		}
  
  197
  
  	}
  
  198
  >
  	return t, false
  
tally_metrics_handler.go

  199
  
  }
  
  200

  202
  
  // canonical tag values for cache key computation. Returns the original slice
  
  203
  
  // unchanged if no tags need normalization (zero-alloc fast path).
  
  204
  >
  func normalizeTagsForCaching(tags []Tag, excl excludeTags) []Tag {
  
tally_metrics_handler.go

  205
  >
  	if len(excl) == 0 {
  
  206
  >
  		return tags
  
tally_metrics_handler.go

  207
  >
  	}
  
  208
  
  	var normalized []Tag
  
  209
  
  	for i, t := range tags {

  223
  
  224
  
  // Counter obtains a counter for the given name.
  
  225
  >
  func (tmh *tallyMetricsHandler) Counter(counter string) CounterIface {
  
tally_metrics_handler.go

  226
  >
  	if v, ok := tmh.counters.Load(counter); ok {
  
  227
  >
  		return v.(CounterIface) //nolint:revive // type-safe: only CounterIface is stored
  
tally_metrics_handler.go

  228
  >
  	}
  
  229
  >
  	c := CounterFunc(func(i int64, t ...Tag) {
  
tally_metrics_handler.go

  230
  >
  		tmh.cachedTaggedScope(t).Counter(counter).Inc(i)
  
  231
  >
  	})
  
  232
  >
  	actual, _ := tmh.counters.LoadOrStore(counter, c)
  
  233
  >
  	return actual.(CounterIface) //nolint:revive // type-safe: only CounterIface is stored
  
  234
  
  }
  
  235

  247
  
  248
  
  // Timer obtains a timer for the given name.
  
  249
  >
  func (tmh *tallyMetricsHandler) Timer(timer string) TimerIface {
  
tally_metrics_handler.go

  250
  >
  	if v, ok := tmh.timers.Load(timer); ok {
  
  251
  >
  		return v.(TimerIface) //nolint:revive // type-safe: only TimerIface is stored
  
tally_metrics_handler.go

  252
  >
  	}
  
  253
  >
  	ti := TimerFunc(func(d time.Duration, t ...Tag) {
  
tally_metrics_handler.go

  254
  >
  		tmh.cachedTaggedScope(t).Timer(timer).Record(d)
  
  255
  >
  	})
  
  256
  >
  	actual, _ := tmh.timers.LoadOrStore(timer, ti)
  
  257
  >
  	return actual.(TimerIface) //nolint:revive // type-safe: only TimerIface is stored
  
  258
  
  }
  
  259
  
  260
  
  // Histogram obtains a histogram for the given name.
  
  261
  >
  func (tmh *tallyMetricsHandler) Histogram(histogram string, unit MetricUnit) HistogramIface {
  
tally_metrics_handler.go

  262
  >
  	key := histogramCacheKey{name: histogram, unit: unit}
  
  263
  >
  	if v, ok := tmh.histograms.Load(key); ok {
  
  264
  >
  		return v.(HistogramIface) //nolint:revive // type-safe: only HistogramIface is stored
  
tally_metrics_handler.go

  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/chasm/search_attribute.go 121 covered LOC · 18 ranges

Open complete file

  136
  
  }
  
  137
  
  138
  >
  func newSearchAttributeFieldBool(index int) SearchAttributeFieldBool {
  
search_attribute.go

  139
  >
  	return SearchAttributeFieldBool{
  
  140
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_BOOL, index),
  
  141
  >
  	}
  
  142
  >
  }
  
  143
  
  144
  
  // SearchAttributeFieldDateTime is a search attribute field for a datetime value.

  147
  
  }
  
  148
  
  149
  >
  func newSearchAttributeFieldDateTime(index int) SearchAttributeFieldDateTime {
  
search_attribute.go

  150
  >
  	return SearchAttributeFieldDateTime{
  
  151
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_DATETIME, index),
  
  152
  >
  	}
  
  153
  >
  }
  
  154
  
  155
  
  // SearchAttributeFieldInt is a search attribute field for an integer value.

  158
  
  }
  
  159
  
  160
  >
  func newSearchAttributeFieldInt(index int) SearchAttributeFieldInt {
  
search_attribute.go

  161
  >
  	return SearchAttributeFieldInt{
  
  162
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_INT, index),
  
  163
  >
  	}
  
  164
  >
  }
  
  165
  
  166
  
  // SearchAttributeFieldDouble is a search attribute field for a double value.

  169
  
  }
  
  170
  
  171
  >
  func newSearchAttributeFieldDouble(index int) SearchAttributeFieldDouble {
  
search_attribute.go

  172
  >
  	return SearchAttributeFieldDouble{
  
  173
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_DOUBLE, index),
  
  174
  >
  	}
  
  175
  >
  }
  
  176
  
  177
  
  // SearchAttributeFieldKeyword is a search attribute field for a keyword value.

  180
  
  }
  
  181
  
  182
  >
  func newSearchAttributeFieldKeyword(index int) SearchAttributeFieldKeyword {
  
search_attribute.go

  183
  >
  	return SearchAttributeFieldKeyword{
  
  184
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_KEYWORD, index),
  
  185
  >
  	}
  
  186
  >
  }
  
  187
  
  188
  >
  func newSearchAttributeFieldLowCardinalityKeyword(index int) SearchAttributeFieldKeyword {
  
search_attribute.go

  189
  >
  	return SearchAttributeFieldKeyword{
  
  190
  >
  		field: fmt.Sprintf("%s%s%02d", sadefs.ReservedPrefix, "LowCardinalityKeyword", index),
  
  191
  >
  	}
  
  192
  >
  }
  
  193
  
  194
  
  // SearchAttributeFieldKeywordList is a search attribute field for a keyword list value.

  197
  
  }
  
  198
  
  199
  >
  func newSearchAttributeFieldKeywordList(index int) SearchAttributeFieldKeywordList {
  
search_attribute.go

  200
  >
  	return SearchAttributeFieldKeywordList{
  
  201
  >
  		field: resolveFieldName(enumspb.INDEXED_VALUE_TYPE_KEYWORD_LIST, index),
  
  202
  >
  	}
  
  203
  >
  }
  
  204
  
  205
  
  // SearchAttributeFieldText is a search attribute field for a text value.

  214
  
  }
  
  215
  
  216
  >
  func resolveFieldName(valueType enumspb.IndexedValueType, index int) string {
  
search_attribute.go

  217
  >
  	// Columns are named like TemporalBool01, TemporalDatetime01, TemporalDouble01, TemporalInt01.
  
  218
  >
  	return fmt.Sprintf("%s%s%02d", sadefs.ReservedPrefix, valueType.String(), index)
  
  219
  >
  }
  
  220
  
  221
  >
  func (s searchAttributeDefinition) definition() searchAttributeDefinition {
  
search_attribute.go

  222
  >
  	return s
  
  223
  >
  }
  
  224
  
  225
  
  // SearchAttributeBool is a search attribute for a boolean value.

  229
  
  230
  
  // NewSearchAttributeBool creates a new boolean search attribute given a predefined chasm field
  
  231
  >
  func NewSearchAttributeBool(alias string, boolField SearchAttributeFieldBool) SearchAttributeBool {
  
search_attribute.go

  232
  >
  	return SearchAttributeBool{
  
  233
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  234
  >
  			alias:     alias,
  
  235
  >
  			field:     boolField.field,
  
  236
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_BOOL,
  
  237
  >
  		},
  
  238
  >
  	}
  
  239
  >
  }
  
  240
  
  241
  >
  func newSearchAttributeBoolByField(field string) SearchAttributeBool {
  
search_attribute.go

  242
  >
  	return SearchAttributeBool{
  
  243
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  244
  >
  			alias:     field,
  
  245
  >
  			field:     field,
  
  246
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_BOOL,
  
  247
  >
  		},
  
  248
  >
  	}
  
  249
  >
  }
  
  250
  
  251
  
  // Value sets the boolean value of the search attribute.
  
  252
  >
  func (s SearchAttributeBool) Value(value bool) SearchAttributeKeyValue {
  
search_attribute.go

  253
  >
  	return SearchAttributeKeyValue{
  
  254
  >
  		Alias: s.alias,
  
  255
  >
  		Field: s.field,
  
  256
  >
  		Value: VisibilityValueBool(value),
  
  257
  >
  	}
  
  258
  >
  }
  
  259
  
  260
  
  func (s SearchAttributeBool) typeMarker(_ bool) {}

  266
  
  267
  
  // NewSearchAttributeDateTime creates a new date time search attribute given a predefined chasm field
  
  268
  >
  func NewSearchAttributeDateTime(alias string, datetimeField SearchAttributeFieldDateTime) SearchAttributeDateTime {
  
search_attribute.go

  269
  >
  	return SearchAttributeDateTime{
  
  270
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  271
  >
  			alias:     alias,
  
  272
  >
  			field:     datetimeField.field,
  
  273
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_DATETIME,
  
  274
  >
  		},
  
  275
  >
  	}
  
  276
  >
  }
  
  277
  
  278
  >
  func newSearchAttributeDateTimeByField(field string) SearchAttributeDateTime {
  
search_attribute.go

  279
  >
  	return SearchAttributeDateTime{
  
  280
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  281
  >
  			alias:     field,
  
  282
  >
  			field:     field,
  
  283
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_DATETIME,
  
  284
  >
  		},
  
  285
  >
  	}
  
  286
  >
  }
  
  287
  
  288
  
  // Value sets the date time value of the search attribute.

  303
  
  304
  
  // NewSearchAttributeInt creates a new integer search attribute given a predefined chasm field
  
  305
  >
  func NewSearchAttributeInt(alias string, intField SearchAttributeFieldInt) SearchAttributeInt {
  
search_attribute.go

  306
  >
  	return SearchAttributeInt{
  
  307
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  308
  >
  			alias:     alias,
  
  309
  >
  			field:     intField.field,
  
  310
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_INT,
  
  311
  >
  		},
  
  312
  >
  	}
  
  313
  >
  }
  
  314
  
  315
  
  // Value sets the integer value of the search attribute.

  367
  
  368
  
  // NewSearchAttributeKeyword creates a new keyword search attribute given a predefined chasm field
  
  369
  >
  func NewSearchAttributeKeyword(alias string, keywordField SearchAttributeFieldKeyword) SearchAttributeKeyword {
  
search_attribute.go

  370
  >
  	return SearchAttributeKeyword{
  
  371
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  372
  >
  			alias:     alias,
  
  373
  >
  			field:     keywordField.field,
  
  374
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD,
  
  375
  >
  		},
  
  376
  >
  	}
  
  377
  >
  }
  
  378
  
  379
  >
  func newSearchAttributeKeywordByField(field string) SearchAttributeKeyword {
  
search_attribute.go

  380
  >
  	return SearchAttributeKeyword{
  
  381
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  382
  >
  			alias:     field,
  
  383
  >
  			field:     field,
  
  384
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD,
  
  385
  >
  		},
  
  386
  >
  	}
  
  387
  >
  }
  
  388
  
  389
  
  // Value sets the string value of the search attribute.

  414
  
  }
  
  415
  
  416
  >
  func newSearchAttributeKeywordListByField(field string) SearchAttributeKeywordList {
  
search_attribute.go

  417
  >
  	return SearchAttributeKeywordList{
  
  418
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  419
  >
  			alias:     field,
  
  420
  >
  			field:     field,
  
  421
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_KEYWORD_LIST,
  
  422
  >
  		},
  
  423
  >
  	}
  
  424
  >
  }
  
  425
  
  426
  
  // Value sets the string list value of the search attribute.

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

Open complete file

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

  129
  >
  	return entry.size
  
  130
  >
  }
  
  131
  
  132
  
  func (entry *entryImpl) CreateTime() time.Time {

  135
  
  136
  
  // New creates a new cache with the given options
  
  137
  >
  func New(maxSize int, opts *Options) StoppableCache {
  
lru.go

  138
  >
  	return NewWithMetrics(maxSize, opts, metrics.NoopMetricsHandler)
  
  139
  >
  }
  
  140
  
  141
  
  // NewWithMetrics creates a new cache that will emit capacity and ttl metrics.
  
  142
  
  // handler should be tagged with metrics.CacheTypeTag.
  
  143
  >
  func NewWithMetrics(maxSize int, opts *Options, handler metrics.Handler) StoppableCache {
  
lru.go

  144
  >
  	if opts == nil {
  
  145
  
  		opts = &Options{}
  
  146
  
  	}
  
  147
  
  148
  >
  	backgroundEvict := opts.BackgroundEvict
  
lru.go

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

  151
  >
  			return dynamicconfig.CacheBackgroundEvictSettings{
  
  152
  >
  				Enabled: false,
  
  153
  >
  			}
  
  154
  >
  		}
  
  155
  
  	}
  
  156
  
  157
  >
  	timeSource := opts.TimeSource
  
lru.go

  158
  >
  	if timeSource == nil {
  
  159
  >
  		timeSource = clock.NewRealTimeSource()
  
lru.go

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

  163
  >
  	metrics.CacheTtl.With(handler).Record(opts.TTL)
  
  164
  >
  	c := &lru{
  
  165
  >
  		byAccess:        list.New(),
  
  166
  >
  		byKey:           make(map[any]*list.Element),
  
  167
  >
  		ttl:             opts.TTL,
  
  168
  >
  		maxSize:         maxSize,
  
  169
  >
  		currSize:        0,
  
  170
  >
  		pin:             opts.Pin,
  
  171
  >
  		onPut:           opts.OnPut,
  
  172
  >
  		onEvict:         opts.OnEvict,
  
  173
  >
  		timeSource:      timeSource,
  
  174
  >
  		metricsHandler:  handler,
  
  175
  >
  		backgroundEvict: backgroundEvict,
  
  176
  >
  	}
  
  177
  >
  	if c.backgroundEvict().Enabled {
  
  178
  
  		c.loops.Go(c.bgEvictLoop)
  
  179
  
  	}
  
  180
  >
  	return c
  
lru.go

  181
  
  }
  
  182

  188
  
  189
  
  // Get retrieves the value stored under the given key
  
  190
  >
  func (c *lru) Get(key any) any {
  
lru.go

  191
  >
  	if c.maxSize == 0 { //
  
  192
  
  		return nil
  
  193
  
  	}
  
  194
  >
  	c.mut.Lock()
  
lru.go

  195
  >
  	defer c.mut.Unlock()
  
  196
  >
  
  197
  >
  	element := c.byKey[key]
  
  198
  >
  	if element == nil {
  
  199
  >
  		return nil
  
lru.go

  200
  >
  	}
  
  201
  
  202
  
  	entry := element.Value.(*entryImpl)

  225
  
  226
  
  // PutIfNotExist puts a value associated with a given key if it does not exist
  
  227
  >
  func (c *lru) PutIfNotExist(key any, value any) (any, error) {
  
lru.go

  228
  >
  	existing, err := c.putInternal(key, value, false)
  
  229
  >
  	if err != nil {
  
  230
  
  		return nil, err
  
  231
  
  	}
  
  232
  
  233
  >
  	if existing == nil {
  
lru.go

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

  235
  >
  		return value, err
  
  236
  >
  	}
  
  237
  
  238
  
  	return existing, err

  254
  
  255
  
  // Release decrements the ref count of a pinned element.
  
  256
  >
  func (c *lru) Release(key any) {
  
lru.go

  257
  >
  	if c.maxSize == 0 || !c.pin {
  
  258
  
  		return
  
  259
  
  	}
  
  260
  >
  	c.mut.Lock()
  
lru.go

  261
  >
  	defer c.mut.Unlock()
  
  262
  >
  
  263
  >
  	elt, ok := c.byKey[key]
  
  264
  >
  	if !ok {
  
  265
  
  		return
  
  266
  
  	}
  
  267
  >
  	entry := elt.Value.(*entryImpl)
  
lru.go

  268
  >
  	entry.refCount--
  
  269
  >
  	if entry.refCount == 0 {
  
  270
  >
  		c.pinnedSize -= entry.Size()
  
lru.go

  271
  >
  		metrics.CachePinnedUsage.With(c.metricsHandler).Record(float64(c.pinnedSize))
  
  272
  >
  	}
  
  273
  
  	// Entry size might have changed. Recalculate size and evict entries if necessary.
  
  274
  >
  	newEntrySize := getSize(entry.value)
  
lru.go

  275
  >
  	c.currSize = c.calculateNewCacheSize(newEntrySize, entry.Size())
  
  276
  >
  	entry.size = newEntrySize
  
  277
  >
  	if c.currSize > c.maxSize {
  
  278
  
  		c.tryEvictUntilCacheSizeUnderLimit()
  
  279
  
  	}
  
  280
  >
  	metrics.CacheUsage.With(c.metricsHandler).Record(float64(c.currSize))
  
lru.go

  281
  
  }
  
  282

  294
  
  // Put puts a new value associated with a given key, returning the existing value (if present)
  
  295
  
  // allowUpdate flag is used to control overwrite behavior if the value exists.
  
  296
  >
  func (c *lru) putInternal(key any, value any, allowUpdate bool) (any, error) {
  
lru.go

  297
  >
  	if c.maxSize == 0 {
  
  298
  
  		return nil, nil
  
  299
  
  	}
  
  300
  >
  	newEntrySize := getSize(value)
  
lru.go

  301
  >
  	if newEntrySize > c.maxSize {
  
  302
  
  		return nil, ErrCacheItemTooLarge
  
  303
  
  	}
  
  304
  
  305
  >
  	c.mut.Lock()
  
lru.go

  306
  >
  	defer c.mut.Unlock()
  
  307
  >
  
  308
  >
  	elt := c.byKey[key]
  
  309
  >
  	// If the entry exists, check if it has expired or update the value
  
  310
  >
  	if elt != nil {
  
  311
  
  		existingEntry := elt.Value.(*entryImpl)
  
  312
  
  		if !c.isEntryExpired(existingEntry, c.timeSource.Now().UTC()) {

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

  350
  >
  
  351
  >
  	// check if the new entry can fit in the cache
  
  352
  >
  	newCacheSize := c.calculateNewCacheSize(newEntrySize, emptyEntrySize)
  
  353
  >
  	if newCacheSize > c.maxSize {
  
  354
  
  		return nil, ErrCacheFull
  
  355
  
  	}
  
  356
  
  357
  >
  	entry := &entryImpl{
  
lru.go

  358
  >
  		key:   key,
  
  359
  >
  		value: value,
  
  360
  >
  		size:  newEntrySize,
  
  361
  >
  	}
  
  362
  >
  	c.updateEntryTTL(entry)
  
  363
  >
  	c.updateEntryRefCount(entry)
  
  364
  >
  	element := c.byAccess.PushFront(entry)
  
  365
  >
  	c.byKey[key] = element
  
  366
  >
  	c.currSize = newCacheSize
  
  367
  >
  	metrics.CacheUsage.With(c.metricsHandler).Record(float64(c.currSize))
  
  368
  >
  
  369
  >
  	if c.onPut != nil {
  
  370
  >
  		c.onPut(value)
  
lru.go

  371
  >
  	}
  
  372
  
  373
  >
  	return nil, nil
  
lru.go

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

  377
  >
  	return c.currSize - existingEntrySize + newEntrySize
  
  378
  >
  }
  
  379
  
  380
  
  func (c *lru) deleteInternal(element *list.Element) {

  397
  
  // tryEvictUntilEnoughSpaceWithSkipEntry try to evict entries until there is enough space for the new entry without
  
  398
  
  // evicting the existing entry. the existing entry is skipped because it is being updated.
  
  399
  >
  func (c *lru) tryEvictUntilEnoughSpaceWithSkipEntry(newEntrySize int, existingEntry *entryImpl) {
  
lru.go

  400
  >
  	element := c.byAccess.Back()
  
  401
  >
  	existingEntrySize := 0
  
  402
  >
  	if existingEntry != nil {
  
  403
  
  		existingEntrySize = existingEntry.Size()
  
  404
  
  	}
  
  405
  
  406
  >
  	for c.calculateNewCacheSize(newEntrySize, existingEntrySize) > c.maxSize && element != nil {
  
lru.go

  407
  
  		entry := element.Value.(*entryImpl)
  
  408
  
  		if existingEntry != nil && entry.key == existingEntry.key {

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

  433
  >
  	if c.ttl != 0 {
  
  434
  >
  		entry.createTime = c.timeSource.Now().UTC()
  
lru.go

  435
  >
  	}
  
  436
  
  }
  
  437
  
  438
  >
  func (c *lru) updateEntryRefCount(entry *entryImpl) {
  
lru.go

  439
  >
  	if c.pin {
  
  440
  >
  		entry.refCount++
  
lru.go

  441
  >
  		if entry.refCount == 1 {
  
  442
  >
  			c.pinnedSize += entry.Size()
  
  443
  >
  			metrics.CachePinnedUsage.With(c.metricsHandler).Record(float64(c.pinnedSize))
  
  444
  >
  		}
  
  445
  
  	}
  
  446
  
  }

go.temporal.io/server/service/history/chasm_engine.go 117 covered LOC · 33 ranges

Open complete file

  86
  
  	historyServiceResolver membership.ServiceResolver,
  
  87
  
  	hostInfoProvider membership.HostInfoProvider,
  
  88
  >
  ) *ChasmEngine {
  
chasm_engine.go

  89
  >
  	return &ChasmEngine{
  
  90
  >
  		executionCache:         executionCache,
  
  91
  >
  		registry:               registry,
  
  92
  >
  		config:                 config,
  
  93
  >
  		notifier:               notifier,
  
  94
  >
  		logger:                 logger,
  
  95
  >
  		historyServiceResolver: historyServiceResolver,
  
  96
  >
  		hostInfoProvider:       hostInfoProvider,
  
  97
  >
  	}
  
  98
  >
  }
  
  99
  
  100
  
  // This is for breaking fx cycle dependency.

  102
  
  func (e *ChasmEngine) SetShardController(
  
  103
  
  	shardController shard.Controller,
  
  104
  >
  ) {
  
chasm_engine.go

  105
  >
  	e.shardController = shardController
  
  106
  >
  }
  
  107
  
  108
  
  func (e *ChasmEngine) NotifyExecution(key chasm.ExecutionKey) {

  685
  
  	monotonicPredicate func(chasm.Context, chasm.Component) (bool, error),
  
  686
  
  	opts ...chasm.TransitionOption,
  
  687
  >
  ) ([]byte, error) {
  
chasm_engine.go

  688
  >
  	options := e.constructTransitionOptions(opts...)
  
  689
  >
  	result, err := e.pollComponent(ctx, requestRef, monotonicPredicate)
  
  690
  >
  	return result, e.convertError(err, requestRef, options.RequestID)
  
  691
  >
  }
  
  692
  
  693
  
  func (e *ChasmEngine) pollComponent(

  695
  
  	requestRef chasm.ComponentRef,
  
  696
  
  	monotonicPredicate func(chasm.Context, chasm.Component) (bool, error),
  
  697
  >
  ) (retRef []byte, retError error) {
  
chasm_engine.go

  698
  >
  
  699
  >
  	var ch <-chan struct{}
  
  700
  >
  	var unsubscribe func()
  
  701
  >
  	defer func() {
  
  702
  >
  		if unsubscribe != nil {
  
  703
  
  			unsubscribe()
  
  704
  
  		}
  
  705
  
  	}()
  
  706
  
  707
  >
  	checkPredicateOrSubscribe := func() ([]byte, error) {
  
chasm_engine.go

  708
  >
  		_, executionLease, err := e.getExecutionLease(ctx, requestRef)
  
  709
  >
  		if err != nil {
  
  710
  >
  			return nil, err
  
chasm_engine.go

  711
  >
  		}
  
  712
  
  		defer executionLease.GetReleaseFn()(nil) //nolint:revive
  
  713

  729
  
  	}
  
  730
  
  731
  >
  	ref, err := checkPredicateOrSubscribe()
  
chasm_engine.go

  732
  >
  	if err != nil || ref != nil {
  
  733
  >
  		return ref, err
  
chasm_engine.go

  734
  >
  	}
  
  735
  
  736
  
  	for {

  778
  
  func (e *ChasmEngine) constructTransitionOptions(
  
  779
  
  	opts ...chasm.TransitionOption,
  
  780
  >
  ) chasm.TransitionOptions {
  
chasm_engine.go

  781
  >
  	options := defaultTransitionOptions
  
  782
  >
  	for _, opt := range opts {
  
  783
  
  		opt(&options)
  
  784
  
  	}
  
  785
  >
  	if options.RequestID == "" {
  
chasm_engine.go

  786
  >
  		options.RequestID = primitives.NewUUID().String()
  
chasm_engine.go

  787
  >
  	}
  
  788
  >
  	return options
  
chasm_engine.go

  789
  
  }
  
  790

  1135
  
  func (e *ChasmEngine) getShardContext(
  
  1136
  
  	ref chasm.ComponentRef,
  
  1137
  >
  ) (historyi.ShardContext, error) {
  
chasm_engine.go

  1138
  >
  	return e.shardController.GetShardByID(
  
  1139
  >
  		common.WorkflowIDToHistoryShard(
  
  1140
  >
  			ref.NamespaceID,
  
  1141
  >
  			ref.BusinessID,
  
  1142
  >
  			e.config.NumberOfShards,
  
  1143
  >
  		),
  
  1144
  >
  	)
  
  1145
  >
  }
  
  1146
  
  1147
  
  // getExecutionLease returns shard context and mutable state for the chasm execution, with the lock

  1154
  
  	ctx context.Context,
  
  1155
  
  	ref chasm.ComponentRef,
  
  1156
  >
  ) (historyi.ShardContext, api.WorkflowLease, error) {
  
chasm_engine.go

  1157
  >
  	shardContext, err := e.getShardContext(ref)
  
  1158
  >
  	if err != nil {
  
  1159
  
  		return nil, nil, err
  
  1160
  
  	}
  
  1161
  
  1162
  >
  	consistencyChecker := api.NewWorkflowConsistencyChecker(
  
chasm_engine.go

  1163
  >
  		shardContext,
  
  1164
  >
  		e.executionCache,
  
  1165
  >
  	)
  
  1166
  >
  
  1167
  >
  	lockPriority := locks.PriorityHigh
  
  1168
  >
  	callerType := headers.GetCallerInfo(ctx).CallerType
  
  1169
  >
  	if callerType == headers.CallerTypeBackgroundHigh ||
  
  1170
  >
  		callerType == headers.CallerTypeBackgroundLow ||
  
  1171
  >
  		callerType == headers.CallerTypePreemptable {
  
  1172
  
  		lockPriority = locks.PriorityLow
  
  1173
  
  	}
  
  1174
  
  1175
  >
  	archetypeID, err := ref.ArchetypeID(e.registry)
  
chasm_engine.go

  1176
  >
  	if err != nil {
  
  1177
  
  		return nil, nil, err
  
  1178
  
  	}
  
  1179
  
  1180
  >
  	var predicateErr error
  
chasm_engine.go

  1181
  >
  	var needReload bool
  
  1182
  >
  	executionLease, err := consistencyChecker.GetChasmLeaseWithConsistencyCheck(
  
  1183
  >
  		ctx,
  
  1184
  >
  		nil,
  
  1185
  >
  		func(mutableState historyi.MutableState) bool {
  
  1186
  >
  			err := mutableState.ChasmTree().IsStale(ref)
  
chasm_engine.go

  1187
  >
  			needReload = errors.Is(err, consts.ErrStaleState)
  
  1188
  >
  			if !needReload {
  
  1189
  
  				// Reference itself might be stale.
  
  1190
  
  				// No need to reload mutable state in this case, but request should be failed.

  1194
  
  			// Return false (i.e. consistency predicate check failed)
  
  1195
  
  			// here to indicate reload is needed.
  
  1196
  >
  			return !needReload
  
chasm_engine.go

  1197
  
  		},
  
  1198
  
  		definition.NewWorkflowKey(

  1204
  
  		lockPriority,
  
  1205
  
  	)
  
  1206
  >
  	if err != nil {
  
chasm_engine.go

  1207
  
  		return nil, nil, err
  
  1208
  
  	}
  
  1209
  
  1210
  >
  	if predicateErr != nil {
  
chasm_engine.go

  1211
  
  		executionLease.GetReleaseFn()(nil)
  
  1212
  
  		return nil, nil, predicateErr
  
  1213
  
  	}
  
  1214
  
  1215
  >
  	if !needReload {
  
chasm_engine.go

  1216
  
  		return shardContext, executionLease, nil
  
  1217
  
  	}

  1219
  
  	// Mutable state was previously detected as stale and got reloaded,
  
  1220
  
  	// do a final check to ensure mutable state is not stale after reload.
  
  1221
  >
  	err = executionLease.GetMutableState().ChasmTree().IsStale(ref)
  
chasm_engine.go

  1222
  >
  	if err != nil {
  
  1223
  >
  		logger := log.With(shardContext.GetLogger(),
  
  1224
  >
  			tag.WorkflowNamespaceID(ref.NamespaceID),
  
  1225
  >
  			tag.WorkflowID(ref.BusinessID),
  
  1226
  >
  			tag.WorkflowRunID(ref.RunID),
  
  1227
  >
  		)
  
  1228
  >
  
  1229
  >
  		if errors.Is(err, consts.ErrStaleState) {
  
  1230
  >
  			// This could happen when there's a replication lag upon force failover,
  
  1231
  >
  			// and caller is using the reference from the original cluster in the
  
  1232
  >
  			// new cluster before replication catches up.
  
  1233
  >
  			//
  
  1234
  >
  			// This could also happen due to data loss in the database,
  
  1235
  >
  			// but we can't really distinguish the two cases here, so always return
  
  1236
  >
  			// a retryable error here.
  
  1237
  >
  			//
  
  1238
  >
  			// TODO: consider adding a clusterID field to the generated token to distinguish
  
  1239
  >
  			// the two cases.
  
  1240
  >
  			logger.Warn(
  
  1241
  >
  				"stale state after mutable state reload, could due to force namespace failover or data loss",
  
  1242
  >
  				tag.Error(err),
  
  1243
  >
  			)
  
  1244
  >
  
  1245
  >
  			executionLease.GetReleaseFn()(nil)
  
  1246
  >
  			return nil, nil, serviceerror.NewUnavailablef("stale state, please retry")
  
  1247
  >
  		}
  
  1248
  
  1249
  
  		// Stale reference case is already handled above.

  1269
  
  	ref chasm.ComponentRef,
  
  1270
  
  	requestID string,
  
  1271
  >
  ) error {
  
chasm_engine.go

  1272
  >
  	if err == nil {
  
  1273
  
  		return nil
  
  1274
  
  	}
  
  1275
  
  1276
  >
  	if solErr, ok := errors.AsType[*persistence.ShardOwnershipLostError](err); ok {
  
chasm_engine.go

  1277
  
  		hostInfo := e.hostInfoProvider.HostInfo()
  
  1278
  
  		e.logger.Error("chasm ShardOwnershipLostError", tag.Error(err), tag.RequestID(requestID))

  1282
  
  		return serviceerrors.NewShardOwnershipLost("", hostInfo.GetAddress())
  
  1283
  
  	}
  
  1284
  >
  	if _, ok := errors.AsType[*persistence.AppendHistoryTimeoutError](err); ok {
  
chasm_engine.go

  1285
  
  		e.logger.Error("chasm AppendHistoryTimeoutError", tag.Error(err), tag.RequestID(requestID))
  
  1286
  
  		return serviceerror.NewUnavailablef("append history timed out (request ID: %s)", requestID)
  
  1287
  
  	}
  
  1288
  >
  	if _, ok := errors.AsType[*persistence.WorkflowConditionFailedError](err); ok {
  
chasm_engine.go

  1289
  
  		e.logger.Error("chasm WorkflowConditionFailedError", tag.Error(err), tag.RequestID(requestID))
  
  1290
  
  		return serviceerror.NewUnavailablef("workflow condition failed (request ID: %s)", requestID)
  
  1291
  
  	}
  
  1292
  >
  	if cwcfe, ok := errors.AsType[*persistence.CurrentWorkflowConditionFailedError](err); ok {
  
chasm_engine.go

  1293
  
  		e.logger.Error("chasm CurrentWorkflowConditionFailedError", tag.Error(err), tag.RequestID(requestID))
  
  1294
  
  		return serviceerror.NewUnavailablef("current workflow condition failed for RunID %s (request ID: %s)", cwcfe.RunID, requestID)
  
  1295
  
  	}
  
  1296
  >
  	if _, ok := errors.AsType[*persistence.ConditionFailedError](err); ok {
  
chasm_engine.go

  1297
  
  		e.logger.Error("chasm ConditionFailedError", tag.Error(err), tag.RequestID(requestID))
  
  1298
  
  		return serviceerror.NewUnavailablef("condition failed (request ID: %s)", requestID)
  
  1299
  
  	}
  
  1300
  >
  	if _, ok := errors.AsType[*persistence.TransactionSizeLimitError](err); ok {
  
chasm_engine.go

  1301
  
  		e.logger.Error("chasm TransactionSizeLimitError", tag.Error(err), tag.RequestID(requestID))
  
  1302
  
  		return serviceerror.NewInvalidArgumentf("transaction size limit exceeded (request ID: %s)", requestID)
  
  1303
  
  	}
  
  1304
  >
  	if _, ok := errors.AsType[*persistence.TimeoutError](err); ok {
  
chasm_engine.go

  1305
  
  		e.logger.Error("chasm TimeoutError", tag.Error(err), tag.RequestID(requestID))
  
  1306
  
  		return serviceerror.NewDeadlineExceededf("persistence operation timed out (request ID: %s)", requestID)
  
  1307
  
  	}
  
  1308
  
  1309
  >
  	if _, ok := errors.AsType[*serviceerror.NotFound](err); !ok {
  
chasm_engine.go

  1310
  >
  		return err
  
chasm_engine.go

  1311
  >
  	}
  
  1312
  
  1313
  
  	return e.convertNotFoundError(err, ref)

go.temporal.io/server/service/history/workflow/cache/cache.go 115 covered LOC · 31 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

  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/log/zap_logger.go 110 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
  
  126
  
  	}
  
  127
  >
  	return msg
  
zap_logger.go

  128
  
  }
  
  129

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

  139
  >
  	if l.zl.Core().Enabled(zap.InfoLevel) {
  
  140
  >
  		msg = setDefaultMsg(msg)
  
  141
  >
  		fields := l.buildFieldsWithCallAt(tags)
  
  142
  >
  		l.zl.Info(msg, fields...)
  
  143
  >
  	}
  
  144
  
  }
  
  145
  
  146
  >
  func (l *zapLogger) Warn(msg string, tags ...tag.Tag) {
  
zap_logger.go

  147
  >
  	if l.zl.Core().Enabled(zap.WarnLevel) {
  
  148
  >
  		msg = setDefaultMsg(msg)
  
  149
  >
  		fields := l.buildFieldsWithCallAt(tags)
  
  150
  >
  		l.zl.Warn(msg, fields...)
  
  151
  >
  	}
  
  152
  
  }
  
  153

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

  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/api/persistence/v1/chasm.pb.go 108 covered LOC · 28 ranges

Open complete file

  50
  
  func (*ChasmNode) ProtoMessage() {}
  
  51
  
  52
  >
  func (x *ChasmNode) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  53
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[0]
  
  54
  >
  	if x != nil {
  
  55
  >
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
chasm.pb.go

  56
  >
  		if ms.LoadMessageInfo() == nil {
  
  57
  >
  			ms.StoreMessageInfo(mi)
  
  58
  >
  		}
  
  59
  >
  		return ms
  
  60
  
  	}
  
  61
  
  	return mi.MessageOf(x)

  67
  
  }
  
  68
  
  69
  >
  func (x *ChasmNode) GetMetadata() *ChasmNodeMetadata {
  
chasm.pb.go

  70
  >
  	if x != nil {
  
  71
  >
  		return x.Metadata
  
  72
  >
  	}
  
  73
  
  	return nil
  
  74
  
  }
  
  75
  
  76
  >
  func (x *ChasmNode) GetData() *v1.DataBlob {
  
chasm.pb.go

  77
  >
  	if x != nil {
  
  78
  >
  		return x.Data
  
  79
  >
  	}
  
  80
  
  	return nil
  
  81
  
  }

  111
  
  func (*ChasmNodeMetadata) ProtoMessage() {}
  
  112
  
  113
  >
  func (x *ChasmNodeMetadata) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  114
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[1]
  
  115
  >
  	if x != nil {
  
  116
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  117
  
  		if ms.LoadMessageInfo() == nil {

  120
  
  		return ms
  
  121
  
  	}
  
  122
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  123
  
  }
  
  124

  142
  
  }
  
  143
  
  144
  >
  func (x *ChasmNodeMetadata) GetAttributes() isChasmNodeMetadata_Attributes {
  
chasm.pb.go

  145
  >
  	if x != nil {
  
  146
  >
  		return x.Attributes
  
  147
  >
  	}
  
  148
  
  	return nil
  
  149
  
  }
  
  150
  
  151
  >
  func (x *ChasmNodeMetadata) GetComponentAttributes() *ChasmComponentAttributes {
  
chasm.pb.go

  152
  >
  	if x != nil {
  
  153
  >
  		if x, ok := x.Attributes.(*ChasmNodeMetadata_ComponentAttributes); ok {
  
chasm.pb.go

  154
  >
  			return x.ComponentAttributes
  
chasm.pb.go

  155
  >
  		}
  
  156
  
  	}
  
  157
  
  	return nil

  250
  
  func (*ChasmComponentAttributes) ProtoMessage() {}
  
  251
  
  252
  >
  func (x *ChasmComponentAttributes) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  253
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[2]
  
  254
  >
  	if x != nil {
  
  255
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  256
  
  		if ms.LoadMessageInfo() == nil {

  259
  
  		return ms
  
  260
  
  	}
  
  261
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  262
  
  }
  
  263

  267
  
  }
  
  268
  
  269
  >
  func (x *ChasmComponentAttributes) GetTypeId() uint32 {
  
chasm.pb.go

  270
  >
  	if x != nil {
  
  271
  >
  		return x.TypeId
  
  272
  >
  	}
  
  273
  
  	return 0
  
  274
  
  }

  429
  
  func (*ChasmDataAttributes) ProtoMessage() {}
  
  430
  
  431
  >
  func (x *ChasmDataAttributes) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  432
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[5]
  
  433
  >
  	if x != nil {
  
  434
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  435
  
  		if ms.LoadMessageInfo() == nil {

  438
  
  		return ms
  
  439
  
  	}
  
  440
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  441
  
  }
  
  442

  465
  
  func (*ChasmCollectionAttributes) ProtoMessage() {}
  
  466
  
  467
  >
  func (x *ChasmCollectionAttributes) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  468
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[6]
  
  469
  >
  	if x != nil {
  
  470
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  471
  
  		if ms.LoadMessageInfo() == nil {

  474
  
  		return ms
  
  475
  
  	}
  
  476
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  477
  
  }
  
  478

  502
  
  func (*ChasmPointerAttributes) ProtoMessage() {}
  
  503
  
  504
  >
  func (x *ChasmPointerAttributes) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  505
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[7]
  
  506
  >
  	if x != nil {
  
  507
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  508
  
  		if ms.LoadMessageInfo() == nil {

  511
  
  		return ms
  
  512
  
  	}
  
  513
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  514
  
  }
  
  515

  571
  
  func (*ChasmTaskInfo) ProtoMessage() {}
  
  572
  
  573
  >
  func (x *ChasmTaskInfo) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  574
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[8]
  
  575
  >
  	if x != nil {
  
  576
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  577
  
  		if ms.LoadMessageInfo() == nil {

  580
  
  		return ms
  
  581
  
  	}
  
  582
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  583
  
  }
  
  584

  660
  
  }
  
  661
  
  662
  >
  func (x *ChasmComponentRef) Reset() {
  
chasm.pb.go

  663
  >
  	*x = ChasmComponentRef{}
  
  664
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[9]
  
  665
  >
  	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  666
  >
  	ms.StoreMessageInfo(mi)
  
  667
  >
  }
  
  668
  
  669
  
  func (x *ChasmComponentRef) String() string {

  673
  
  func (*ChasmComponentRef) ProtoMessage() {}
  
  674
  
  675
  >
  func (x *ChasmComponentRef) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  676
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[9]
  
  677
  >
  	if x != nil {
  
  678
  >
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  679
  >
  		if ms.LoadMessageInfo() == nil {
  
  680
  >
  			ms.StoreMessageInfo(mi)
  
  681
  >
  		}
  
  682
  >
  		return ms
  
  683
  
  	}
  
  684
  
  	return mi.MessageOf(x)

  908
  
  func (*ChasmComponentAttributes_Task) ProtoMessage() {}
  
  909
  
  910
  >
  func (x *ChasmComponentAttributes_Task) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  911
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[11]
  
  912
  >
  	if x != nil {
  
  913
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  914
  
  		if ms.LoadMessageInfo() == nil {

  917
  
  		return ms
  
  918
  
  	}
  
  919
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  920
  
  }
  
  921

  999
  
  func (*ChasmComponentAttributes_RequestMetadata) ProtoMessage() {}
  
  1000
  
  1001
  >
  func (x *ChasmComponentAttributes_RequestMetadata) ProtoReflect() protoreflect.Message {
  
chasm.pb.go

  1002
  >
  	mi := &file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[12]
  
  1003
  >
  	if x != nil {
  
  1004
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1005
  
  		if ms.LoadMessageInfo() == nil {

  1008
  
  		return ms
  
  1009
  
  	}
  
  1010
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  1011
  
  }
  
  1012

  1180
  
  }
  
  1181
  
  1182
  >
  func init() { file_temporal_server_api_persistence_v1_chasm_proto_init() }
  
chasm.pb.go

  1183
  >
  func file_temporal_server_api_persistence_v1_chasm_proto_init() {
  
  1184
  >
  	if File_temporal_server_api_persistence_v1_chasm_proto != nil {
  
  1185
  >
  		return
  
  1186
  >
  	}
  
  1187
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_init()
  
  1188
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[1].OneofWrappers = []any{
  
  1189
  >
  		(*ChasmNodeMetadata_ComponentAttributes)(nil),
  
  1190
  >
  		(*ChasmNodeMetadata_DataAttributes)(nil),
  
  1191
  >
  		(*ChasmNodeMetadata_CollectionAttributes)(nil),
  
  1192
  >
  		(*ChasmNodeMetadata_PointerAttributes)(nil),
  
  1193
  >
  	}
  
  1194
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_msgTypes[10].OneofWrappers = []any{
  
  1195
  >
  		(*ChasmNexusCompletion_Success)(nil),
  
  1196
  >
  		(*ChasmNexusCompletion_Failure)(nil),
  
  1197
  >
  	}
  
  1198
  >
  	type x struct{}
  
  1199
  >
  	out := protoimpl.TypeBuilder{
  
  1200
  >
  		File: protoimpl.DescBuilder{
  
  1201
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1202
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_chasm_proto_rawDesc), len(file_temporal_server_api_persistence_v1_chasm_proto_rawDesc)),
  
  1203
  >
  			NumEnums:      0,
  
  1204
  >
  			NumMessages:   15,
  
  1205
  >
  			NumExtensions: 0,
  
  1206
  >
  			NumServices:   0,
  
  1207
  >
  		},
  
  1208
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_chasm_proto_goTypes,
  
  1209
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_chasm_proto_depIdxs,
  
  1210
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_chasm_proto_msgTypes,
  
  1211
  >
  	}.Build()
  
  1212
  >
  	File_temporal_server_api_persistence_v1_chasm_proto = out.File
  
  1213
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_goTypes = nil
  
  1214
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_depIdxs = nil
  
  1215
  
  }

go.temporal.io/server/service/history/shard/context_testutil.go 102 covered LOC · 8 ranges

Open complete file

  56
  
  	shardInfo *persistencespb.ShardInfo,
  
  57
  
  	config *configs.Config,
  
  58
  >
  ) *ContextTest {
  
context_testutil.go

  59
  >
  	resourceTest := resourcetest.NewTest(ctrl, primitives.HistoryService)
  
  60
  >
  	eventsCache := events.NewMockCache(ctrl)
  
  61
  >
  	shard := newTestContext(
  
  62
  >
  		resourceTest,
  
  63
  >
  		eventsCache,
  
  64
  >
  		ContextConfigOverrides{
  
  65
  >
  			ShardInfo: shardInfo,
  
  66
  >
  			Config:    config,
  
  67
  >
  		},
  
  68
  >
  	)
  
  69
  >
  	return &ContextTest{
  
  70
  >
  		Resource:        resourceTest,
  
  71
  >
  		ContextImpl:     shard,
  
  72
  >
  		MockEventsCache: eventsCache,
  
  73
  >
  	}
  
  74
  >
  }
  
  75
  
  76
  
  type ContextConfigOverrides struct {

  107
  
  }
  
  108
  
  109
  >
  func newTestContext(t *resourcetest.Test, eventsCache events.Cache, config ContextConfigOverrides) *ContextImpl {
  
context_testutil.go

  110
  >
  	hostInfoProvider := t.GetHostInfoProvider()
  
  111
  >
  	lifecycleCtx, lifecycleCancel := context.WithCancel(context.Background())
  
  112
  >
  	if config.ShardInfo.QueueStates == nil {
  
  113
  >
  		config.ShardInfo.QueueStates = make(map[int32]*persistencespb.QueueState)
  
context_testutil.go

  114
  >
  	}
  
  115
  >
  	registry := config.Registry
  
context_testutil.go

  116
  >
  	if registry == nil {
  
  117
  >
  		registry = t.GetNamespaceRegistry()
  
  118
  >
  	}
  
  119
  >
  	clusterMetadata := config.ClusterMetadata
  
  120
  >
  	if clusterMetadata == nil {
  
  121
  >
  		clusterMetadata = t.GetClusterMetadata()
  
  122
  >
  	}
  
  123
  >
  	executionManager := config.ExecutionManager
  
  124
  >
  	if executionManager == nil {
  
  125
  >
  		executionManager = t.ExecutionMgr
  
  126
  >
  	}
  
  127
  >
  	taskCategoryRegistry := tasks.NewDefaultTaskCategoryRegistry()
  
  128
  >
  	taskCategoryRegistry.AddCategory(tasks.CategoryArchival)
  
  129
  >
  
  130
  >
  	ctx := &ContextImpl{
  
  131
  >
  		shardID:             config.ShardInfo.GetShardId(),
  
  132
  >
  		owner:               config.ShardInfo.GetOwner(),
  
  133
  >
  		stringRepr:          fmt.Sprintf("Shard(%d)", config.ShardInfo.GetShardId()),
  
  134
  >
  		executionManager:    executionManager,
  
  135
  >
  		metricsHandler:      t.MetricsHandler,
  
  136
  >
  		eventsCache:         eventsCache,
  
  137
  >
  		config:              config.Config,
  
  138
  >
  		contextTaggedLogger: t.GetLogger(),
  
  139
  >
  		throttledLogger:     t.GetThrottledLogger(),
  
  140
  >
  		lifecycleCtx:        lifecycleCtx,
  
  141
  >
  		lifecycleCancel:     lifecycleCancel,
  
  142
  >
  		queueMetricEmitter:  sync.Once{},
  
  143
  >
  
  144
  >
  		state:              contextStateAcquired,
  
  145
  >
  		engineFuture:       future.NewFuture[historyi.Engine](),
  
  146
  >
  		shardInfo:          config.ShardInfo,
  
  147
  >
  		remoteClusterInfos: make(map[string]*remoteClusterInfo),
  
  148
  >
  
  149
  >
  		clusterMetadata:      clusterMetadata,
  
  150
  >
  		timeSource:           t.TimeSource,
  
  151
  >
  		namespaceRegistry:    registry,
  
  152
  >
  		stateMachineRegistry: hsm.NewRegistry(),
  
  153
  >
  		chasmRegistry:        chasm.NewRegistry(t.GetLogger()),
  
  154
  >
  		businessIDRateLimiters: cache.New(
  
  155
  >
  			config.Config.BusinessIDReuseLimiterCacheSize(),
  
  156
  >
  			&cache.Options{TTL: config.Config.BusinessIDReuseLimiterCacheTTL()},
  
  157
  >
  		),
  
  158
  >
  		persistenceShardManager: t.GetShardManager(),
  
  159
  >
  		clientBean:              t.GetClientBean(),
  
  160
  >
  		saProvider:              t.GetSearchAttributesProvider(),
  
  161
  >
  		saMapperProvider:        t.GetSearchAttributesMapperProvider(),
  
  162
  >
  		historyClient:           t.GetHistoryClient(),
  
  163
  >
  		payloadSerializer:       t.GetPayloadSerializer(),
  
  164
  >
  		archivalMetadata:        t.GetArchivalMetadata(),
  
  165
  >
  		hostInfoProvider:        hostInfoProvider,
  
  166
  >
  		taskCategoryRegistry:    taskCategoryRegistry,
  
  167
  >
  		ioSemaphore:             locks.NewPrioritySemaphore(1),
  
  168
  >
  	}
  
  169
  >
  	ctx.taskKeyManager = newTaskKeyManager(
  
  170
  >
  		ctx.taskCategoryRegistry,
  
  171
  >
  		ctx.timeSource,
  
  172
  >
  		config.Config,
  
  173
  >
  		ctx.GetLogger(),
  
  174
  >
  		func() error {
  
  175
  
  			return ctx.renewRangeLocked(false)
  
  176
  
  		},
  
  177
  
  	)
  
  178
  >
  	ctx.taskKeyManager.setRangeID(config.ShardInfo.RangeId)
  
context_testutil.go

  179
  >
  	ctx.handoverTracker = NewDefaultHandoverTrackerFactory()(HandoverTrackerParams{
  
  180
  >
  		ClusterMetadata:         clusterMetadata,
  
  181
  >
  		GetMaxReplicationTaskID: ctx.getMaxReplicationTaskID,
  
  182
  >
  		ErrorByStateFn:          ctx.errorByState,
  
  183
  >
  		NotifyReplicationFn:     ctx.notifyReplicationQueueProcessor,
  
  184
  >
  		NamespaceRegistry:       registry,
  
  185
  >
  		Logger:                  ctx.contextTaggedLogger,
  
  186
  >
  	})
  
  187
  >
  	return ctx
  
  188
  
  }
  
  189
  
  190
  
  // SetEngineForTest sets s.engine. Only used by tests.
  
  191
  >
  func (s *ContextTest) SetEngineForTesting(engine historyi.Engine) {
  
context_testutil.go

  192
  >
  	s.engineFuture.Set(engine, nil)
  
  193
  >
  }
  
  194
  
  195
  
  // SetEventsCacheForTesting sets s.eventsCache. Only used by tests.

  216
  
  217
  
  // SetStateMachineRegistry sets the state machine registry on this shard.
  
  218
  >
  func (s *ContextTest) SetStateMachineRegistry(reg *hsm.Registry) {
  
context_testutil.go

  219
  >
  	s.stateMachineRegistry = reg
  
  220
  >
  }
  
  221
  
  222
  >
  func (s *ContextTest) SetChasmRegistry(reg *chasm.Registry) {
  
context_testutil.go

  223
  >
  	s.chasmRegistry = reg
  
  224
  >
  }
  
  225
  
  226
  
  func (s *ContextTest) SetChasmWorkflowRegistry(reg *chasmworkflow.Registry) {

go.temporal.io/server/service/history/shard/context_impl.go 83 covered LOC · 26 ranges

Open complete file

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

  213
  >
  	// constant from initialization, no need for locks
  
  214
  >
  	return s.shardID
  
  215
  >
  }
  
  216
  
  217
  
  func (s *ContextImpl) GetRangeID() int64 {

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

  225
  >
  	// constant from initialization, no need for locks
  
  226
  >
  	return s.owner
  
  227
  >
  }
  
  228
  
  229
  
  func (s *ContextImpl) GetExecutionManager() persistence.ExecutionManager {

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

  316
  >
  	s.rLock()
  
  317
  >
  	defer s.rUnlock()
  
  318
  >
  
  319
  >
  	nextTaskKey := s.taskKeyManager.peekTaskKey(tasks.CategoryTransfer)
  
  320
  >
  	return vclock.NewVectorClock(s.clusterMetadata.GetClusterID(), s.shardID, nextTaskKey.TaskID)
  
  321
  >
  }
  
  322
  
  323
  
  func (s *ContextImpl) GenerateTaskID() (int64, error) {

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

  331
  >
  	return s.finalizer
  
  332
  >
  }
  
  333
  
  334
  
  func (s *ContextImpl) GenerateTaskIDs(number int) ([]int64, error) {

  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 {

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

  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:

  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

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

  1531
  >
  	s.rwLock.RUnlock()
  
  1532
  >
  }
  
  1533
  
  1534
  
  func (s *ContextImpl) ioSemaphoreAcquire(

  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 {

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/context.go 77 covered LOC · 22 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
  
  134
  >
  func (c *ContextImpl) Clear() {
  
context.go

  135
  >
  	metrics.WorkflowContextCleared.With(c.metricsHandler).Record(1)
  
  136
  >
  	if c.MutableState != nil {
  
  137
  >
  		c.MutableState.GetQueryRegistry().Clear()
  
context.go

  138
  >
  		c.MutableState.RemoveSpeculativeWorkflowTaskTimeoutTask()
  
  139
  >
  		c.MutableState = nil
  
  140
  >
  	}
  
  141
  >
  	if c.updateRegistry != nil {
  
context.go

  142
  
  		c.updateRegistry.Clear()
  
  143
  
  		c.updateRegistry = nil
  
  144
  
  	}
  
  145
  >
  	c.clearTaskCompletionBuffer()
  
context.go

  146
  
  }
  
  147
  
  148
  
  // clearTaskCompletionBuffer drops the in-progress buffer
  
  149
  >
  func (c *ContextImpl) clearTaskCompletionBuffer() {
  
context.go

  150
  >
  	if c.taskCompletionBuffer == nil {
  
  151
  >
  		return
  
context.go

  152
  >
  	}
  
  153
  
  	c.taskCompletionBuffer = nil
  
  154
  
  }

  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(

  1418
  
  // CacheSize estimates the in-memory size of the object for cache limits. For proto objects, it uses proto.Size()
  
  1419
  
  // which returns the serialized size. Note: In-memory size will be slightly larger than the serialized size.
  
  1420
  >
  func (c *ContextImpl) CacheSize() int {
  
context.go

  1421
  >
  	if !c.config.HistoryCacheLimitSizeBased {
  
  1422
  >
  		return 1
  
context.go

  1423
  >
  	}
  
  1424
  
  	size := len(c.workflowKey.WorkflowID) + len(c.workflowKey.RunID) + len(c.workflowKey.NamespaceID)
  
  1425
  
  	if c.MutableState != nil {

go.temporal.io/server/chasm/registry.go 74 covered LOC · 33 ranges

Open complete file

  51
  
  }
  
  52
  
  53
  >
  func NewRegistry(logger log.Logger) *Registry {
  
registry.go

  54
  >
  	return &Registry{
  
  55
  >
  		libraries:              make(map[string]Library),
  
  56
  >
  		rcByFqn:                make(map[string]*RegistrableComponent),
  
  57
  >
  		rcByID:                 make(map[uint32]*RegistrableComponent),
  
  58
  >
  		rcByGoType:             make(map[reflect.Type]*RegistrableComponent),
  
  59
  >
  		rtByFqn:                make(map[string]*RegistrableTask),
  
  60
  >
  		rtByID:                 make(map[uint32]*RegistrableTask),
  
  61
  >
  		rtByGoType:             make(map[reflect.Type]*RegistrableTask),
  
  62
  >
  		rcContextValues:        make(map[any]valueWithFqn),
  
  63
  >
  		nexusServices:          make(map[string]*nexus.Service),
  
  64
  >
  		NexusEndpointProcessor: NewNexusEndpointProcessor(),
  
  65
  >
  		logger:                 logger,
  
  66
  >
  	}
  
  67
  >
  }
  
  68
  
  69
  >
  func (r *Registry) Register(lib Library) error {
  
registry.go

  70
  >
  	if err := r.validateName(lib.Name()); err != nil {
  
  71
  
  		return err
  
  72
  
  	}
  
  73
  >
  	if _, ok := r.libraries[lib.Name()]; ok {
  
registry.go

  74
  
  		return fmt.Errorf("library %s is already registered", lib.Name())
  
  75
  
  	}
  
  76
  >
  	r.libraries[lib.Name()] = lib
  
registry.go

  77
  >
  
  78
  >
  	for _, c := range lib.Components() {
  
  79
  >
  		if err := r.registerComponent(lib, c); err != nil {
  
registry.go

  80
  
  			return err
  
  81
  
  		}
  
  82
  
  	}
  
  83
  >
  	for _, t := range lib.Tasks() {
  
registry.go

  84
  
  		if err := r.registerTask(lib, t); err != nil {
  
  85
  
  			return err

  87
  
  	}
  
  88
  
  89
  >
  	for _, svc := range lib.NexusServices() {
  
registry.go

  90
  
  		if err := r.registerNexusService(svc); err != nil {
  
  91
  
  			return err

  93
  
  	}
  
  94
  
  95
  >
  	for _, svc := range lib.NexusServiceProcessors() {
  
registry.go

  96
  
  		if err := r.NexusEndpointProcessor.RegisterServiceProcessor(svc); err != nil {
  
  97
  
  			return err

  99
  
  	}
  
  100
  
  101
  >
  	return nil
  
registry.go

  102
  
  }
  
  103

  134
  
  // This method should only be used by CHASM framework internal code,
  
  135
  
  // NOT CHASM library developers.
  
  136
  >
  func (r *Registry) ComponentByID(id uint32) (*RegistrableComponent, bool) {
  
registry.go

  137
  >
  	rc, ok := r.rcByID[id]
  
  138
  >
  	return rc, ok
  
  139
  >
  }
  
  140
  
  141
  
  // ComponentIDFor converts registered component instance to component type ID.
  
  142
  
  // This method should only be used by CHASM framework internal code,
  
  143
  
  // NOT CHASM library developers.
  
  144
  >
  func (r *Registry) ComponentIDFor(componentInstance any) (uint32, bool) {
  
registry.go

  145
  >
  	rc, ok := r.componentFor(componentInstance)
  
  146
  >
  	if !ok {
  
  147
  
  		return 0, false
  
  148
  
  	}
  
  149
  >
  	return rc.componentID, true
  
registry.go

  150
  
  }
  
  151

  183
  
  // This method should only be used by CHASM framework internal code,
  
  184
  
  // NOT CHASM library developers.
  
  185
  >
  func (r *Registry) ArchetypeDisplayName(id ArchetypeID) (string, bool) {
  
registry.go

  186
  >
  	rc, ok := r.ComponentByID(id)
  
  187
  >
  	if !ok {
  
  188
  
  		return "", false
  
  189
  
  	}
  
  190
  >
  	return rc.componentType, true
  
registry.go

  191
  
  }
  
  192

  212
  
  }
  
  213
  
  214
  >
  func (r *Registry) componentFor(componentInstance any) (*RegistrableComponent, bool) {
  
registry.go

  215
  >
  	rc, ok := r.rcByGoType[reflect.TypeOf(componentInstance)]
  
  216
  >
  	return rc, ok
  
  217
  >
  }
  
  218
  
  219
  
  func (r *Registry) taskFor(taskInstance any) (*RegistrableTask, bool) {

  235
  
  	lib namer,
  
  236
  
  	rc *RegistrableComponent,
  
  237
  >
  ) error {
  
registry.go

  238
  >
  	if err := r.validate(rc); err != nil {
  
  239
  
  		return err
  
  240
  
  	}
  
  241
  
  242
  >
  	fqn, id, err := rc.registerToLibrary(lib)
  
registry.go

  243
  >
  	if err != nil {
  
  244
  
  		return err
  
  245
  
  	}
  
  246
  
  247
  >
  	if _, ok := r.rcByFqn[fqn]; ok {
  
registry.go

  248
  
  		return fmt.Errorf("component %s is already registered", fqn)
  
  249
  
  	}
  
  250
  
  251
  >
  	if id == UnspecifiedArchetypeID {
  
registry.go

  252
  
  		return fmt.Errorf("component %s maps to a reserved archetype id %d, please use a different name", fqn, UnspecifiedArchetypeID)
  
  253
  
  	}
  
  254
  
  255
  >
  	if existingComponent, ok := r.rcByID[id]; ok {
  
registry.go

  256
  
  		return fmt.Errorf("component ID %d collision between %s and %s", id, fqn, existingComponent.fqType())
  
  257
  
  	}
  
  258
  
  259
  >
  	for key, value := range rc.contextValues {
  
registry.go

  260
  
  		if existingValue, ok := r.rcContextValues[key]; ok {
  
  261
  
  			return fmt.Errorf("context value key %v registered by component %s conflicts with component %s", key, fqn, existingValue.fqn)

  269
  
  	// rc.goType implements Component interface; therefore, it must be a struct.
  
  270
  
  	// This check to protect against the interface itself being registered.
  
  271
  >
  	if !(rc.goType.Kind() == reflect.Struct ||
  
registry.go

  272
  >
  		(rc.goType.Kind() == reflect.Pointer && rc.goType.Elem().Kind() == reflect.Struct)) {
  
  273
  
  		return fmt.Errorf("component type %s must be struct or pointer to struct", rc.goType.String())
  
  274
  
  	}
  
  275
  >
  	if _, ok := r.rcByGoType[rc.goType]; ok {
  
registry.go

  276
  
  		return fmt.Errorf("component type %s is already registered", rc.goType.String())
  
  277
  
  	}
  
  278
  >
  	r.warnUnmanagedFields(fqn, rc)
  
registry.go

  279
  >
  
  280
  >
  	r.rcByFqn[fqn] = rc
  
  281
  >
  	r.rcByID[id] = rc
  
  282
  >
  	r.rcByGoType[rc.goType] = rc
  
  283
  >
  	return nil
  
  284
  
  }
  
  285
  
  286
  >
  func (r *Registry) validate(rc *RegistrableComponent) error {
  
registry.go

  287
  >
  	if err := r.validateName(rc.componentType); err != nil {
  
  288
  
  		return err
  
  289
  
  	}
  
  290
  >
  	return r.validateVisibilityBusinessIDAlias(rc)
  
registry.go

  291
  
  }
  
  292

  332
  
  }
  
  333
  
  334
  >
  func (r *Registry) validateName(n string) error {
  
registry.go

  335
  >
  	if n == "" {
  
  336
  
  		return errors.New("name must not be empty")
  
  337
  
  	}
  
  338
  >
  	if !nameValidator.MatchString(n) {
  
registry.go

  339
  
  		return fmt.Errorf("name %s is invalid. name must follow golang identifier rules: %s", n, nameValidator.String())
  
  340
  
  	}
  
  341
  >
  	return nil
  
registry.go

  342
  
  }
  
  343
  
  344
  >
  func (r *Registry) validateVisibilityBusinessIDAlias(rc *RegistrableComponent) error {
  
registry.go

  345
  >
  	if !hasVisibilityField(rc.goType) {
  
  346
  >
  		return nil
  
registry.go

  347
  >
  	}
  
  348
  
  	// Archetypes that contain a Field[*Visibility] must specify WithBusinessIDAlias.
  
  349
  
  	if !rc.hasBusinessIDAlias() {

  353
  
  }
  
  354
  
  355
  >
  func (r *Registry) warnUnmanagedFields(fqn string, rc *RegistrableComponent) {
  
registry.go

  356
  >
  	var unmanagedFields []string
  
  357
  >
  	for f := range unmanagedFieldsOf(rc.goType) {
  
  358
  
  		unmanagedFields = append(unmanagedFields, fmt.Sprintf("%s %s", f.name, f.typ))
  
  359
  
  	}
  
  360
  >
  	if len(unmanagedFields) > 0 {
  
registry.go

  361
  
  		r.logger.Info(fmt.Sprintf(
  
  362
  
  			"Warning: CHASM component %s declares state fields that won't be managed by CHASM:\n\t%s",

go.temporal.io/server/api/persistence/v1/hsm.pb.go 56 covered LOC · 13 ranges

Open complete file

  147
  
  func (*StateMachineMap) ProtoMessage() {}
  
  148
  
  149
  >
  func (x *StateMachineMap) ProtoReflect() protoreflect.Message {
  
hsm.pb.go

  150
  >
  	mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[1]
  
  151
  >
  	if x != nil {
  
  152
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  153
  
  		if ms.LoadMessageInfo() == nil {

  156
  
  		return ms
  
  157
  
  	}
  
  158
  >
  	return mi.MessageOf(x)
  
hsm.pb.go

  159
  
  }
  
  160

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

  275
  >
  	mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[3]
  
  276
  >
  	if x != nil {
  
  277
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  278
  
  		if ms.LoadMessageInfo() == nil {

  281
  
  		return ms
  
  282
  
  	}
  
  283
  >
  	return mi.MessageOf(x)
  
hsm.pb.go

  284
  
  }
  
  285

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

  352
  >
  	mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[4]
  
  353
  >
  	if x != nil {
  
  354
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  355
  
  		if ms.LoadMessageInfo() == nil {

  358
  
  		return ms
  
  359
  
  	}
  
  360
  >
  	return mi.MessageOf(x)
  
hsm.pb.go

  361
  
  }
  
  362

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

  419
  >
  	mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[5]
  
  420
  >
  	if x != nil {
  
  421
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  422
  
  		if ms.LoadMessageInfo() == nil {

  425
  
  		return ms
  
  426
  
  	}
  
  427
  >
  	return mi.MessageOf(x)
  
hsm.pb.go

  428
  
  }
  
  429

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

  481
  >
  	mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[6]
  
  482
  >
  	if x != nil {
  
  483
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  484
  
  		if ms.LoadMessageInfo() == nil {

  487
  
  		return ms
  
  488
  
  	}
  
  489
  >
  	return mi.MessageOf(x)
  
hsm.pb.go

  490
  
  }
  
  491

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

  534
  >
  	mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[7]
  
  535
  >
  	if x != nil {
  
  536
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  537
  
  		if ms.LoadMessageInfo() == nil {

  540
  
  		return ms
  
  541
  
  	}
  
  542
  >
  	return mi.MessageOf(x)
  
hsm.pb.go

  543
  
  }
  
  544

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

  898
  >
  func file_temporal_server_api_persistence_v1_hsm_proto_init() {
  
  899
  >
  	if File_temporal_server_api_persistence_v1_hsm_proto != nil {
  
  900
  >
  		return
  
  901
  >
  	}
  
  902
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[8].OneofWrappers = []any{
  
  903
  >
  		(*StateMachineTombstone_ActivityScheduledEventId)(nil),
  
  904
  >
  		(*StateMachineTombstone_TimerId)(nil),
  
  905
  >
  		(*StateMachineTombstone_ChildExecutionInitiatedEventId)(nil),
  
  906
  >
  		(*StateMachineTombstone_RequestCancelInitiatedEventId)(nil),
  
  907
  >
  		(*StateMachineTombstone_SignalExternalInitiatedEventId)(nil),
  
  908
  >
  		(*StateMachineTombstone_UpdateId)(nil),
  
  909
  >
  		(*StateMachineTombstone_StateMachinePath)(nil),
  
  910
  >
  		(*StateMachineTombstone_ChasmNodePath)(nil),
  
  911
  >
  	}
  
  912
  >
  	type x struct{}
  
  913
  >
  	out := protoimpl.TypeBuilder{
  
  914
  >
  		File: protoimpl.DescBuilder{
  
  915
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  916
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_hsm_proto_rawDesc), len(file_temporal_server_api_persistence_v1_hsm_proto_rawDesc)),
  
  917
  >
  			NumEnums:      0,
  
  918
  >
  			NumMessages:   12,
  
  919
  >
  			NumExtensions: 0,
  
  920
  >
  			NumServices:   0,
  
  921
  >
  		},
  
  922
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_hsm_proto_goTypes,
  
  923
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_hsm_proto_depIdxs,
  
  924
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_hsm_proto_msgTypes,
  
  925
  >
  	}.Build()
  
  926
  >
  	File_temporal_server_api_persistence_v1_hsm_proto = out.File
  
  927
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_goTypes = nil
  
  928
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_depIdxs = nil
  
  929
  
  }

go.temporal.io/server/common/log/tag/tags.go 48 covered LOC · 15 ranges

Open complete file

  35
  
  36
  
  // Error returns tag for Error
  
  37
  >
  func Error(err error) ZapTag {
  
tags.go

  38
  >
  	return ZapTag{
  
  39
  >
  		// NOTE: zap already chosen "error" as key
  
  40
  >
  		field: zap.Error(err),
  
  41
  >
  	}
  
  42
  >
  }
  
  43
  
  44
  
  // ServiceErrorType returns tag for ServiceErrorType

  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

  524
  
  525
  
  // Number returns tag for Number
  
  526
  >
  func Number(n int64) ZapTag {
  
tags.go

  527
  >
  	return NewInt64("number", n)
  
  528
  >
  }
  
  529
  
  530
  
  // NextNumber returns tag for NextNumber
  
  531
  >
  func NextNumber(n int64) ZapTag {
  
tags.go

  532
  >
  	return NewInt64("next-number", n)
  
  533
  >
  }
  
  534
  
  535
  
  // ServerName returns tag for ServerName

go.temporal.io/server/common/persistence/data_interfaces_mock.go 48 covered LOC · 10 ranges

Open complete file

  67
  
  68
  
  // NewMockShardManager creates a new mock instance.
  
  69
  >
  func NewMockShardManager(ctrl *gomock.Controller) *MockShardManager {
  
data_interfaces_mock.go

  70
  >
  	mock := &MockShardManager{ctrl: ctrl}
  
  71
  >
  	mock.recorder = &MockShardManagerMockRecorder{mock}
  
  72
  >
  	return mock
  
  73
  >
  }
  
  74
  
  75
  
  // EXPECT returns an object that allows the caller to indicate expected use.

  160
  
  161
  
  // NewMockExecutionManager creates a new mock instance.
  
  162
  >
  func NewMockExecutionManager(ctrl *gomock.Controller) *MockExecutionManager {
  
data_interfaces_mock.go

  163
  >
  	mock := &MockExecutionManager{ctrl: ctrl}
  
  164
  >
  	mock.recorder = &MockExecutionManagerMockRecorder{mock}
  
  165
  >
  	return mock
  
  166
  >
  }
  
  167
  
  168
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  169
  >
  func (m *MockExecutionManager) EXPECT() *MockExecutionManagerMockRecorder {
  
data_interfaces_mock.go

  170
  >
  	return m.recorder
  
  171
  >
  }
  
  172
  
  173
  
  // AddHistoryTasks mocks base method.

  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.

  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/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/testing/testvars/test_vars.go 47 covered LOC · 14 ranges

Open complete file

  37
  
  )
  
  38
  
  39
  >
  func New(testNamer testNamer) *TestVars {
  
test_vars.go

  40
  >
  	return newFromName(testNamer.Name())
  
  41
  >
  }
  
  42
  
  43
  >
  func newFromName(testName string) *TestVars {
  
test_vars.go

  44
  >
  	th := hash(testName)
  
  45
  >
  	return &TestVars{
  
  46
  >
  		testName: testName,
  
  47
  >
  		testHash: th,
  
  48
  >
  		an:       newAny(testName, th),
  
  49
  >
  	}
  
  50
  >
  }
  
  51
  
  52
  >
  func getOrCreate[T any](tv *TestVars, key string, initialValGen func(key string) T, valNSetter func(val T, n int) T) T {
  
test_vars.go

  53
  >
  	v, _ := tv.values.LoadOrStore(key, initialValGen(key))
  
  54
  >
  
  55
  >
  	n, ok := tv.numbers.Load(key)
  
  56
  >
  	if !ok {
  
  57
  >
  		//revive:disable-next-line:unchecked-type-assertion
  
test_vars.go

  58
  >
  		return v.(T)
  
  59
  >
  	}
  
  60
  
  61
  
  	//revive:disable-next-line:unchecked-type-assertion

  85
  
  }
  
  86
  
  87
  >
  func (tv *TestVars) uniqueString(key string) string {
  
test_vars.go

  88
  >
  	return fmt.Sprintf("%s_%s", tv.testName, key)
  
  89
  >
  }
  
  90
  
  91
  
  func (tv *TestVars) uuidString(_ string) string {

  93
  
  }
  
  94
  
  95
  >
  func (tv *TestVars) emptyString(_ string) string {
  
test_vars.go

  96
  >
  	return ""
  
  97
  >
  }
  
  98
  
  99
  >
  func (tv *TestVars) clone() *TestVars {
  
test_vars.go

  100
  >
  	tv2 := newFromName(tv.testName)
  
  101
  >
  	tv.values.Range(func(key, value any) bool {
  
  102
  
  		tv2.values.Store(key, value)
  
  103
  
  		return true
  
  104
  
  	})
  
  105
  >
  	tv.numbers.Range(func(key, value any) bool {
  
test_vars.go

  106
  
  		tv2.numbers.Store(key, value)
  
  107
  
  		return true
  
  108
  
  	})
  
  109
  
  110
  >
  	return tv2
  
test_vars.go

  111
  
  }
  
  112
  >
  func (tv *TestVars) cloneSetVal(key string, val any) *TestVars {
  
test_vars.go

  113
  >
  	tv2 := tv.clone()
  
  114
  >
  	tv2.values.Store(key, val)
  
  115
  >
  	return tv2
  
  116
  >
  }
  
  117
  
  118
  
  func (tv *TestVars) cloneSetN(key string, n int) *TestVars {

  186
  
  }
  
  187
  
  188
  >
  func (tv *TestVars) WorkflowID() string {
  
test_vars.go

  189
  >
  	return getOrCreate(tv, "workflow_id", tv.uniqueString, tv.stringNSetter)
  
  190
  >
  }
  
  191
  
  192
  
  func (tv *TestVars) WithWorkflowIDNumber(n int) *TestVars {

  197
  
  // This is to simplify the usage of WorkflowExecution() which most of the time
  
  198
  
  // doesn't need RunID. Otherwise, RunID can be set explicitly using WithRunID.
  
  199
  >
  func (tv *TestVars) RunID() string {
  
test_vars.go

  200
  >
  	return getOrCreate(tv, "run_id", tv.emptyString, tv.uuidNSetter)
  
  201
  >
  }
  
  202
  
  203
  >
  func (tv *TestVars) WithRunID(runID string) *TestVars {
  
test_vars.go

  204
  >
  	return tv.cloneSetVal("run_id", runID)
  
  205
  >
  }
  
  206
  
  207
  
  func (tv *TestVars) WorkflowExecution() *commonpb.WorkflowExecution {

  440
  
  441
  
  // ----------- Generic methods ------------
  
  442
  >
  func (tv *TestVars) Any() Any {
  
test_vars.go

  443
  >
  	return tv.an
  
  444
  >
  }
  
  445
  
  446
  
  func (tv *TestVars) Global() Global {

go.temporal.io/server/common/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/searchattribute/sadefs/constants.go 43 covered LOC · 15 ranges

Open complete file

  261
  
  	}
  
  262
  
  263
  >
  	dbCustomSearchAttributeFieldNameRE = func() map[enumspb.IndexedValueType]*regexp.Regexp {
  
constants.go

  264
  >
  		res := map[enumspb.IndexedValueType]*regexp.Regexp{}
  
  265
  >
  		for t := range defaultNumDBCustomSearchAttributes {
  
  266
  >
  			res[t] = regexp.MustCompile(fmt.Sprintf(`^%s(0[1-9]|[1-9][0-9])$`, t.String()))
  
  267
  >
  		}
  
  268
  >
  		return res
  
  269
  
  	}()
  
  270
  
  )
  
  271
  
  272
  
  // System returns a clone of the system search attributes map.
  
  273
  >
  func System() map[string]enumspb.IndexedValueType {
  
constants.go

  274
  >
  	return maps.Clone(system)
  
  275
  >
  }
  
  276
  
  277
  
  // Predefined returns a clone of the predefined search attributes map.
  
  278
  >
  func Predefined() map[string]enumspb.IndexedValueType {
  
constants.go

  279
  >
  	return maps.Clone(predefined)
  
  280
  >
  }
  
  281
  
  282
  
  // PredefinedWhiteList returns a clone of the predefined whitelist search attributes map.
  
  283
  >
  func PredefinedWhiteList() map[string]enumspb.IndexedValueType {
  
constants.go

  284
  >
  	return maps.Clone(predefinedWhiteList)
  
  285
  >
  }
  
  286
  
  287
  
  // Reserved returns a clone of the reserved field names map.

  291
  
  292
  
  // IsSystem returns true if name is system search attribute
  
  293
  >
  func IsSystem(name string) bool {
  
constants.go

  294
  >
  	_, ok := system[name]
  
  295
  >
  	return ok
  
  296
  >
  }
  
  297
  
  298
  
  // IsReserved returns true if name is system reserved and can't be used as custom search attribute name.
  
  299
  >
  func IsReserved(name string) bool {
  
constants.go

  300
  >
  	if _, ok := system[name]; ok {
  
  301
  
  		return true
  
  302
  
  	}
  
  303
  >
  	if _, ok := predefined[name]; ok {
  
constants.go

  304
  
  		return true
  
  305
  
  	}
  
  306
  >
  	if _, ok := reserved[name]; ok {
  
constants.go

  307
  
  		return true
  
  308
  
  	}
  
  309
  >
  	return strings.HasPrefix(name, ReservedPrefix)
  
constants.go

  310
  
  }
  
  311

  323
  
  324
  
  // IsChasmSystem returns true if name is a system search attribute used by CHASM
  
  325
  >
  func IsChasmSystem(name string) bool {
  
constants.go

  326
  >
  	_, ok := chasmSystemSearchAttributes[name]
  
  327
  >
  	return ok
  
  328
  >
  }
  
  329
  
  330
  
  // IsChasmOverridableSystem returns true if name is a system search attribute whose dedicated

  343
  
  // GetSqlDbColName maps system and reserved search attributes to column names for SQL tables.
  
  344
  
  // If the input is not a system or reserved search attribute, then it returns the input.
  
  345
  >
  func GetSqlDbColName(name string) string {
  
constants.go

  346
  >
  	if fieldName, ok := sqlDbSystemNameToColName[name]; ok {
  
  347
  >
  		return fieldName
  
constants.go

  348
  >
  	}
  
  349
  
  	return name
  
  350
  
  }

  352
  
  func GetDBIndexSearchAttributes(
  
  353
  
  	override map[enumspb.IndexedValueType]int,
  
  354
  >
  ) *persistencespb.IndexSearchAttributes {
  
constants.go

  355
  >
  	csa := map[string]enumspb.IndexedValueType{}
  
  356
  >
  	for saType, defaultNumAttrs := range defaultNumDBCustomSearchAttributes {
  
  357
  >
  		numAttrs := defaultNumAttrs
  
  358
  >
  		if value, ok := override[saType]; ok {
  
  359
  
  			numAttrs = value
  
  360
  
  		}
  
  361
  >
  		for i := range numAttrs {
  
constants.go

  362
  >
  			csa[fmt.Sprintf("%s%02d", saType.String(), i+1)] = saType
  
  363
  >
  		}
  
  364
  
  	}
  
  365
  >
  	return &persistencespb.IndexSearchAttributes{
  
constants.go

  366
  >
  		CustomSearchAttributes: csa,
  
  367
  >
  	}
  
  368
  
  }
  
  369

go.temporal.io/server/chasm/fields_iterator.go 41 covered LOC · 20 ranges

Open complete file

  41
  
  //
  
  42
  
  //nolint:revive // cognitive complexity 26 (> max enabled 25)
  
  43
  >
  func fieldsOf(valueV reflect.Value) iter.Seq[fieldInfo] {
  
fields_iterator.go

  44
  >
  	valueT := valueV.Type()
  
  45
  >
  	dataFieldName := ""
  
  46
  >
  	return func(yield func(fi fieldInfo) bool) {
  
  47
  >
  		for i := 0; i < valueT.Elem().NumField(); i++ {
  
  48
  >
  			fieldV := valueV.Elem().Field(i)
  
  49
  >
  			fieldT := fieldV.Type()
  
  50
  >
  			if fieldT == UnimplementedComponentT {
  
  51
  >
  				continue
  
fields_iterator.go

  52
  
  			}
  
  53
  
  54
  >
  			fieldN := fieldName(valueT.Elem().Field(i))
  
fields_iterator.go

  55
  >
  			var fieldErr error
  
  56
  >
  			fieldK := fieldKindUnspecified
  
  57
  >
  			if fieldT.AssignableTo(protoMessageT) {
  
  58
  >
  				if dataFieldName != "" {
  
fields_iterator.go

  59
  
  					fieldErr = serviceerror.NewInternalf("%s.%s: only one data field %s (implements proto.Message) allowed in component", valueT, fieldN, dataFieldName)
  
  60
  
  				}
  
  61
  >
  				dataFieldName = fieldN
  
fields_iterator.go

  62
  >
  				fieldK = fieldKindData
  
  63
  
  			} else {
  
  64
  
  				prefix := genericTypePrefix(fieldT)

  90
  
  			}
  
  91
  
  92
  >
  			if !yield(fieldInfo{val: fieldV, typ: fieldT, name: fieldN, kind: fieldK, err: fieldErr}) {
  
fields_iterator.go

  93
  
  				return
  
  94
  
  			}
  
  95
  
  		}
  
  96
  
  		// If the data field is not found, generate one more fake field with only an error set.
  
  97
  >
  		if dataFieldName == "" {
  
fields_iterator.go

  98
  
  			yield(fieldInfo{err: serviceerror.NewInternalf("%s: no data field (implements proto.Message) found", valueT)})
  
  99
  
  		}

  102
  
  103
  
  // unmanagedFieldsOf yields all non-CHASM managed fields of a struct.
  
  104
  >
  func unmanagedFieldsOf(valueT reflect.Type) iter.Seq[fieldInfo] {
  
fields_iterator.go

  105
  >
  	return func(yield func(fi fieldInfo) bool) {
  
  106
  >
  		if valueT.Kind() == reflect.Pointer {
  
  107
  >
  			valueT = valueT.Elem()
  
fields_iterator.go

  108
  >
  		}
  
  109
  >
  		for field := range valueT.Fields() {
  
fields_iterator.go

  110
  >
  			fieldT := field.Type
  
  111
  >
  			if fieldT == UnimplementedComponentT {
  
  112
  >
  				continue
  
fields_iterator.go

  113
  
  			}
  
  114
  
  115
  
  			// Skip the data field, which is always CHASM-managed.
  
  116
  >
  			if fieldT.AssignableTo(protoMessageT) {
  
fields_iterator.go

  117
  >
  				continue
  
fields_iterator.go

  118
  
  			}
  
  119

  147
  
  }
  
  148
  
  149
  >
  func fieldName(f reflect.StructField) string {
  
fields_iterator.go

  150
  >
  	if tagName := f.Tag.Get(fieldNameTag); tagName != "" {
  
  151
  
  		return tagName
  
  152
  
  	}
  
  153
  >
  	return f.Name
  
fields_iterator.go

  154
  
  }
  
  155

  161
  
  // This is used at registration time to validate that archetypes using Visibility
  
  162
  
  // have configured a businessID alias.
  
  163
  >
  func hasVisibilityField(componentT reflect.Type) bool {
  
fields_iterator.go

  164
  >
  	if componentT.Kind() == reflect.Pointer {
  
  165
  >
  		componentT = componentT.Elem()
  
fields_iterator.go

  166
  >
  	}
  
  167
  >
  	if componentT.Kind() != reflect.Struct {
  
fields_iterator.go

  168
  
  		return false
  
  169
  
  	}
  
  170
  >
  	for field := range componentT.Fields() {
  
fields_iterator.go

  171
  >
  		fieldT := field.Type
  
  172
  >
  		if fieldT == visibilityFieldT {
  
  173
  
  			return true
  
  174
  
  		}
  
  175
  
  	}
  
  176
  >
  	return false
  
fields_iterator.go

  177
  
  }

go.temporal.io/server/chasm/registrable_component.go 41 covered LOC · 16 ranges

Open complete file

  36
  
  	componentType string,
  
  37
  
  	opts ...RegistrableComponentOption,
  
  38
  >
  ) *RegistrableComponent {
  
registrable_component.go

  39
  >
  	rc := &RegistrableComponent{
  
  40
  >
  		componentType: componentType,
  
  41
  >
  		goType:        reflect.TypeFor[C](),
  
  42
  >
  	}
  
  43
  >
  	for _, opt := range opts {
  
  44
  >
  		opt(rc)
  
registrable_component.go

  45
  >
  	}
  
  46
  >
  	return rc
  
registrable_component.go

  47
  
  }
  
  48

  101
  
  func WithSearchAttributes(
  
  102
  
  	searchAttributes ...SearchAttribute,
  
  103
  >
  ) RegistrableComponentOption {
  
registrable_component.go

  104
  >
  	return func(rc *RegistrableComponent) {
  
  105
  >
  		if len(searchAttributes) == 0 {
  
  106
  
  			return
  
  107
  
  		}
  
  108
  
  109
  >
  		if rc.searchAttributesMapper == nil {
  
registrable_component.go

  110
  >
  			rc.searchAttributesMapper = newVisibilitySearchAttributesMapper()
  
registrable_component.go

  111
  >
  		}
  
  112
  
  113
  >
  		for _, sa := range searchAttributes {
  
registrable_component.go

  114
  >
  			alias := sa.definition().alias
  
  115
  >
  			field := sa.definition().field
  
  116
  >
  			valueType := sa.definition().valueType
  
  117
  >
  
  118
  >
  			// An identity-mapped system search attribute (alias == field, e.g. TaskQueue,
  
  119
  >
  			// ExecutionTime) overrides that system column directly, so it is recorded only in
  
  120
  >
  			// overriddenSystemFields; queries resolve via the system column.
  
  121
  >
  			if field == alias && sadefs.IsSystem(field) {
  
  122
  
  				if !sadefs.IsChasmOverridableSystem(field) {
  
  123
  
  					//nolint:forbidigo

  132
  
  			}
  
  133
  
  134
  >
  			if sadefs.IsChasmSystem(alias) {
  
registrable_component.go

  135
  
  				//nolint:forbidigo
  
  136
  
  				panic(fmt.Sprintf("registrable component validation error: CHASM search attribute alias %q is a CHASM system search attribute", alias))
  
  137
  
  			}
  
  138
  >
  			if !sadefs.IsSystem(alias) && sadefs.IsReserved(alias) {
  
registrable_component.go

  139
  
  				//nolint:forbidigo
  
  140
  
  				panic(fmt.Sprintf("registrable component validation error: CHASM search attribute alias %q is a reserved search attribute", alias))
  
  141
  
  			}
  
  142
  
  143
  >
  			if _, ok := rc.searchAttributesMapper.systemAliasToField[alias]; ok {
  
registrable_component.go

  144
  
  				//nolint:forbidigo
  
  145
  
  				panic(fmt.Sprintf("registrable component validation error: CHASM search attribute alias %q is already defined as a system search attribute alias", alias))
  
  146
  
  			}
  
  147
  >
  			if _, ok := rc.searchAttributesMapper.aliasToField[alias]; ok {
  
registrable_component.go

  148
  
  				//nolint:forbidigo
  
  149
  
  				panic(fmt.Sprintf("registrable component validation error: search attribute alias %q is already defined", alias))
  
  150
  
  			}
  
  151
  >
  			if _, ok := rc.searchAttributesMapper.fieldToAlias[field]; ok {
  
registrable_component.go

  152
  
  				//nolint:forbidigo
  
  153
  
  				panic(fmt.Sprintf("registrable component validation error: search attribute field %q is already defined", field))
  
  154
  
  			}
  
  155
  
  156
  >
  			rc.searchAttributesMapper.aliasToField[alias] = field
  
registrable_component.go

  157
  >
  			rc.searchAttributesMapper.fieldToAlias[field] = alias
  
  158
  >
  			rc.searchAttributesMapper.saTypeMap[field] = valueType
  
  159
  
  		}
  
  160
  
  	}

  184
  
  func (rc *RegistrableComponent) registerToLibrary(
  
  185
  
  	library namer,
  
  186
  >
  ) (string, uint32, error) {
  
registrable_component.go

  187
  >
  	if rc.library != nil {
  
  188
  
  		return "", 0, fmt.Errorf("component %s is already registered in library %s", rc.componentType, rc.library.Name())
  
  189
  
  	}
  
  190
  
  191
  >
  	rc.library = library
  
registrable_component.go

  192
  >
  	rc.fqn = FullyQualifiedName(rc.library.Name(), rc.componentType)
  
  193
  >
  	rc.componentID = GenerateTypeID(rc.fqn)
  
  194
  >
  	return rc.fqn, rc.componentID, nil
  
  195
  
  }
  
  196

  203
  
  // The generated ID is used to uniquely identify components and tasks within the CHASM framework. The same FQN will
  
  204
  
  // always produce the same ID.
  
  205
  >
  func GenerateTypeID(fqn string) uint32 {
  
registrable_component.go

  206
  >
  	return farm.Fingerprint32([]byte(fqn))
  
  207
  >
  }
  
  208
  
  209
  
  // hasBusinessIDAlias returns true if the component has a businessID alias configured

go.temporal.io/server/common/locks/priority_semaphore_impl.go 41 covered LOC · 11 ranges

Open complete file

  67
  
  // maximum combined weight for concurrent access, capable of handling multiple priority levels.
  
  68
  
  // Most of the logic is taken directly from golang's semaphore.Weighted.
  
  69
  >
  func NewPrioritySemaphore(n int) *PrioritySemaphoreImpl {
  
priority_semaphore_impl.go

  70
  >
  	waitLists := make([]*list.List, NumPriorities)
  
  71
  >
  	for i := range waitLists {
  
  72
  >
  		waitLists[i] = list.New()
  
  73
  >
  	}
  
  74
  >
  	return &PrioritySemaphoreImpl{
  
  75
  >
  		size:      n,
  
  76
  >
  		waitLists: waitLists,
  
  77
  >
  	}
  
  78
  
  }
  
  79

  81
  
  // are available or ctx is done. On success, returns nil. On failure, returns
  
  82
  
  // ctx.Err() and leaves the semaphore unchanged.
  
  83
  >
  func (s *PrioritySemaphoreImpl) Acquire(ctx context.Context, priority Priority, n int) error {
  
priority_semaphore_impl.go

  84
  >
  	if priority >= NumPriorities {
  
  85
  
  		// nolint:forbidigo
  
  86
  
  		panic(fmt.Sprintf("semaphore: invalid priority %v, priority must be less than %v", priority, NumPriorities))
  
  87
  
  	}
  
  88
  
  89
  >
  	done := ctx.Done()
  
priority_semaphore_impl.go

  90
  >
  
  91
  >
  	s.mu.Lock()
  
  92
  >
  	select {
  
  93
  
  	case <-done:
  
  94
  
  		// ctx becoming done has "happened before" acquiring the semaphore,

  98
  
  		s.mu.Unlock()
  
  99
  
  		return ctx.Err()
  
  100
  >
  	default:
  
priority_semaphore_impl.go

  101
  
  	}
  
  102
  
  	// Check if acquisition can proceed without waiting
  
  103
  >
  	if s.size-s.cur >= n && s.noWaiters(priority) {
  
priority_semaphore_impl.go

  104
  >
  		// Since we hold s.mu and haven't synchronized since checking done, if
  
priority_semaphore_impl.go

  105
  >
  		// ctx becomes done before we return here, it becoming done must have
  
  106
  >
  		// "happened concurrently" with this call - it cannot "happen before"
  
  107
  >
  		// we return in this branch. So, we're ok to always acquire here.
  
  108
  >
  		s.cur += n
  
  109
  >
  		s.mu.Unlock()
  
  110
  >
  		return nil
  
  111
  >
  	}
  
  112
  
  113
  
  	if n > s.size {

  173
  
  }
  
  174
  
  175
  >
  func (s *PrioritySemaphoreImpl) Release(n int) {
  
priority_semaphore_impl.go

  176
  >
  	s.mu.Lock()
  
  177
  >
  	defer s.mu.Unlock()
  
  178
  >
  	s.cur -= n
  
  179
  >
  	if s.cur < 0 {
  
  180
  
  		s.mu.Unlock()
  
  181
  
  		panic("semaphore: released more than held")
  
  182
  
  	}
  
  183
  >
  	s.notifyWaiters()
  
priority_semaphore_impl.go

  184
  
  }
  
  185
  
  186
  >
  func (s *PrioritySemaphoreImpl) notifyWaiters() {
  
priority_semaphore_impl.go

  187
  >
  	for _, l := range s.waitLists {
  
  188
  >
  		for {
  
  189
  >
  			next := l.Front()
  
  190
  >
  			if next == nil {
  
  191
  >
  				break // No more waiters blocked.
  
  192
  
  			}
  
  193

  219
  
  220
  
  // noWaiters returns if there is no waiter that has priority higher or equal to lowestPriority.
  
  221
  >
  func (s *PrioritySemaphoreImpl) noWaiters(lowestPriority Priority) bool {
  
priority_semaphore_impl.go

  222
  >
  	for _, l := range s.waitLists[:lowestPriority+1] {
  
  223
  >
  		if l.Len() > 0 {
  
  224
  
  			return false
  
  225
  
  		}
  
  226
  
  	}
  
  227
  >
  	return true
  
priority_semaphore_impl.go

  228
  
  }

go.temporal.io/server/service/history/api/consistency_checker.go 40 covered LOC · 11 ranges

Open complete file

  84
  
  	shardContext historyi.ShardContext,
  
  85
  
  	workflowCache wcache.Cache,
  
  86
  >
  ) *WorkflowConsistencyCheckerImpl {
  
consistency_checker.go

  87
  >
  	return &WorkflowConsistencyCheckerImpl{
  
  88
  >
  		shardContext:  shardContext,
  
  89
  >
  		workflowCache: workflowCache,
  
  90
  >
  	}
  
  91
  >
  }
  
  92
  
  93
  
  func (c *WorkflowConsistencyCheckerImpl) GetWorkflowCache() wcache.Cache {

  169
  
  	archetypeID chasm.ArchetypeID,
  
  170
  
  	lockPriority locks.Priority,
  
  171
  >
  ) (WorkflowLease, error) {
  
consistency_checker.go

  172
  >
  	return c.getWorkflowLeaseImpl(ctx, reqClock, consistencyPredicate, workflowKey, archetypeID, lockPriority)
  
  173
  >
  }
  
  174
  
  175
  
  func (c *WorkflowConsistencyCheckerImpl) getWorkflowLeaseImpl(

  180
  
  	archetypeID chasm.ArchetypeID,
  
  181
  
  	lockPriority locks.Priority,
  
  182
  >
  ) (WorkflowLease, error) {
  
consistency_checker.go

  183
  >
  	if err := c.clockConsistencyCheck(reqClock); err != nil {
  
  184
  
  		return nil, err
  
  185
  
  	}
  
  186
  
  187
  >
  	if len(workflowKey.RunID) != 0 {
  
consistency_checker.go

  188
  >
  		return c.getWorkflowLease(ctx, consistencyPredicate, workflowKey, archetypeID, lockPriority)
  
consistency_checker.go

  189
  >
  	}
  
  190
  
  191
  
  	return c.getCurrentWorkflowLease(

  201
  
  func (c *WorkflowConsistencyCheckerImpl) clockConsistencyCheck(
  
  202
  
  	reqClock *clockspb.VectorClock,
  
  203
  >
  ) error {
  
consistency_checker.go

  204
  >
  	if reqClock == nil {
  
  205
  >
  		return nil
  
  206
  >
  	}
  
  207
  
  	currentClock := c.shardContext.CurrentVectorClock()
  
  208
  
  	if !vclock.Comparable(reqClock, currentClock) {

  279
  
  	archetypeID chasm.ArchetypeID,
  
  280
  
  	lockPriority locks.Priority,
  
  281
  >
  ) (WorkflowLease, error) {
  
consistency_checker.go

  282
  >
  
  283
  >
  	wfContext, release, err := c.workflowCache.GetOrCreateChasmExecution(
  
  284
  >
  		ctx,
  
  285
  >
  		c.shardContext,
  
  286
  >
  		namespace.ID(workflowKey.NamespaceID),
  
  287
  >
  		&commonpb.WorkflowExecution{
  
  288
  >
  			WorkflowId: workflowKey.WorkflowID,
  
  289
  >
  			RunId:      workflowKey.RunID,
  
  290
  >
  		},
  
  291
  >
  		archetypeID,
  
  292
  >
  		lockPriority,
  
  293
  >
  	)
  
  294
  >
  	if err != nil {
  
  295
  
  		return nil, err
  
  296
  
  	}
  
  297
  
  298
  >
  	mutableState, err := wfContext.LoadMutableState(ctx, c.shardContext)
  
consistency_checker.go

  299
  >
  	if err != nil {
  
  300
  
  		release(err)
  
  301
  
  		return nil, err

  303
  
  304
  
  	// if consistencyPredicate is nil we assume it is not needed
  
  305
  >
  	if consistencyPredicate == nil || consistencyPredicate(mutableState) {
  
consistency_checker.go

  306
  
  		return NewWorkflowLease(wfContext, release, mutableState), nil
  
  307
  
  	}
  
  308
  >
  	wfContext.Clear()
  
consistency_checker.go

  309
  >
  
  310
  >
  	mutableState, err = wfContext.LoadMutableState(ctx, c.shardContext)
  
  311
  >
  	if err != nil {
  
  312
  
  		release(err)
  
  313
  
  		return nil, err
  
  314
  
  	}
  
  315
  >
  	return NewWorkflowLease(wfContext, release, mutableState), nil
  
consistency_checker.go

  316
  
  }

go.temporal.io/server/service/history/workflow/metrics.go 40 covered LOC · 7 ranges

Open complete file

  40
  
  	archetypeID chasm.ArchetypeID,
  
  41
  
  	stats *persistence.MutableStateStatistics,
  
  42
  >
  ) {
  
metrics.go

  43
  >
  	if stats == nil {
  
  44
  
  		return
  
  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))
  
  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

  98
  
  	}
  
  99
  
  100
  >
  	if name, ok := chasmRegistry.ArchetypeDisplayName(archetypeID); ok {
  
metrics.go

  101
  >
  		return metrics.ArchetypeTag(name), true
  
metrics.go

  102
  >
  	}
  
  103
  
  	return metrics.ArchetypeTag(strconv.FormatUint(uint64(archetypeID), 10)), true
  
  104
  
  }

go.temporal.io/server/common/backoff/retrypolicy.go 38 covered LOC · 7 ranges

Open complete file

  80
  
  81
  
  // NewExponentialRetryPolicy returns an instance of ExponentialRetryPolicy using the provided initialInterval
  
  82
  >
  func NewExponentialRetryPolicy(initialInterval time.Duration) *ExponentialRetryPolicy {
  
retrypolicy.go

  83
  >
  	p := &ExponentialRetryPolicy{
  
  84
  >
  		initialInterval:    initialInterval,
  
  85
  >
  		backoffCoefficient: defaultBackoffCoefficient,
  
  86
  >
  		maximumInterval:    defaultMaximumInterval,
  
  87
  >
  		expirationInterval: defaultExpirationInterval,
  
  88
  >
  		maximumAttempts:    defaultMaximumAttempts,
  
  89
  >
  	}
  
  90
  >
  
  91
  >
  	return p
  
  92
  >
  }
  
  93
  
  94
  
  // NewRetrier is used for creating a new instance of Retrier

  113
  
  // All retries are computed using the following formula:
  
  114
  
  // initialInterval * math.Pow(backoffCoefficient, currentAttempt)
  
  115
  >
  func (p *ExponentialRetryPolicy) WithBackoffCoefficient(backoffCoefficient float64) *ExponentialRetryPolicy {
  
retrypolicy.go

  116
  >
  	p.backoffCoefficient = backoffCoefficient
  
  117
  >
  	return p
  
  118
  >
  }
  
  119
  
  120
  
  // WithMaximumInterval sets the maximum interval for each retry.
  
  121
  
  // This does *not* cause the policy to stop retrying when the interval between retries reaches the supplied duration.
  
  122
  
  // That is what WithExpirationInterval does. Instead, this prevents the interval from exceeding maximumInterval.
  
  123
  >
  func (p *ExponentialRetryPolicy) WithMaximumInterval(maximumInterval time.Duration) *ExponentialRetryPolicy {
  
retrypolicy.go

  124
  >
  	p.maximumInterval = maximumInterval
  
  125
  >
  	return p
  
  126
  >
  }
  
  127
  
  128
  
  // WithExpirationInterval sets the absolute expiration interval for all retries
  
  129
  >
  func (p *ExponentialRetryPolicy) WithExpirationInterval(expirationInterval time.Duration) *ExponentialRetryPolicy {
  
retrypolicy.go

  130
  >
  	p.expirationInterval = expirationInterval
  
  131
  >
  	return p
  
  132
  >
  }
  
  133
  
  134
  
  // WithMaximumAttempts sets the maximum number of retry attempts
  
  135
  >
  func (p *ExponentialRetryPolicy) WithMaximumAttempts(maximumAttempts int) *ExponentialRetryPolicy {
  
retrypolicy.go

  136
  >
  	p.maximumAttempts = maximumAttempts
  
  137
  >
  	return p
  
  138
  >
  }
  
  139
  
  140
  
  // ComputeNextDelay returns the next delay interval.  This is used by Retrier to delay calling the operation again

  267
  
  var _ RetryPolicy = (*ConstantDelayRetryPolicy)(nil)
  
  268
  
  269
  >
  func NewConstantDelayRetryPolicy(delay time.Duration) *ConstantDelayRetryPolicy {
  
retrypolicy.go

  270
  >
  	return &ConstantDelayRetryPolicy{
  
  271
  >
  		maximumAttempts: defaultMaximumAttempts,
  
  272
  >
  		jitterPct:       defaultJitterPct,
  
  273
  >
  		delay:           delay,
  
  274
  >
  	}
  
  275
  >
  }
  
  276
  
  277
  >
  func (p *ConstantDelayRetryPolicy) WithMaximumAttempts(maximumAttempts int) *ConstantDelayRetryPolicy {
  
retrypolicy.go

  278
  >
  	p.maximumAttempts = maximumAttempts
  
  279
  >
  	return p
  
  280
  >
  }
  
  281
  
  282
  
  func (p *ConstantDelayRetryPolicy) WithJitter(jitterPct float64) *ConstantDelayRetryPolicy {

go.temporal.io/server/common/cluster/metadata_mock.go 38 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.

  50
  
  51
  
  // ClusterNameForFailoverVersion indicates an expected call of ClusterNameForFailoverVersion.
  
  52
  >
  func (mr *MockMetadataMockRecorder) ClusterNameForFailoverVersion(isGlobalNamespace, failoverVersion any) *gomock.Call {
  
metadata_mock.go

  53
  >
  	mr.mock.ctrl.T.Helper()
  
  54
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNameForFailoverVersion", reflect.TypeOf((*MockMetadata)(nil).ClusterNameForFailoverVersion), isGlobalNamespace, failoverVersion)
  
  55
  >
  }
  
  56
  
  57
  
  // GetAllClusterInfo mocks base method.

  64
  
  65
  
  // GetAllClusterInfo indicates an expected call of GetAllClusterInfo.
  
  66
  >
  func (mr *MockMetadataMockRecorder) GetAllClusterInfo() *gomock.Call {
  
metadata_mock.go

  67
  >
  	mr.mock.ctrl.T.Helper()
  
  68
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllClusterInfo", reflect.TypeOf((*MockMetadata)(nil).GetAllClusterInfo))
  
  69
  >
  }
  
  70
  
  71
  
  // GetClusterID mocks base method.
  
  72
  >
  func (m *MockMetadata) GetClusterID() int64 {
  
metadata_mock.go

  73
  >
  	m.ctrl.T.Helper()
  
  74
  >
  	ret := m.ctrl.Call(m, "GetClusterID")
  
  75
  >
  	ret0, _ := ret[0].(int64)
  
  76
  >
  	return ret0
  
  77
  >
  }
  
  78
  
  79
  
  // GetClusterID indicates an expected call of GetClusterID.
  
  80
  >
  func (mr *MockMetadataMockRecorder) GetClusterID() *gomock.Call {
  
metadata_mock.go

  81
  >
  	mr.mock.ctrl.T.Helper()
  
  82
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterID", reflect.TypeOf((*MockMetadata)(nil).GetClusterID))
  
  83
  >
  }
  
  84
  
  85
  
  // GetCurrentClusterName mocks base method.

  92
  
  93
  
  // GetCurrentClusterName indicates an expected call of GetCurrentClusterName.
  
  94
  >
  func (mr *MockMetadataMockRecorder) GetCurrentClusterName() *gomock.Call {
  
metadata_mock.go

  95
  >
  	mr.mock.ctrl.T.Helper()
  
  96
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentClusterName", reflect.TypeOf((*MockMetadata)(nil).GetCurrentClusterName))
  
  97
  >
  }
  
  98
  
  99
  
  // GetFailoverVersionIncrement mocks base method.

  162
  
  163
  
  // IsGlobalNamespaceEnabled indicates an expected call of IsGlobalNamespaceEnabled.
  
  164
  >
  func (mr *MockMetadataMockRecorder) IsGlobalNamespaceEnabled() *gomock.Call {
  
metadata_mock.go

  165
  >
  	mr.mock.ctrl.T.Helper()
  
  166
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsGlobalNamespaceEnabled", reflect.TypeOf((*MockMetadata)(nil).IsGlobalNamespaceEnabled))
  
  167
  >
  }
  
  168
  
  169
  
  // IsMasterCluster mocks base method.

  190
  
  191
  
  // IsVersionFromSameCluster indicates an expected call of IsVersionFromSameCluster.
  
  192
  >
  func (mr *MockMetadataMockRecorder) IsVersionFromSameCluster(version1, version2 any) *gomock.Call {
  
metadata_mock.go

  193
  >
  	mr.mock.ctrl.T.Helper()
  
  194
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsVersionFromSameCluster", reflect.TypeOf((*MockMetadata)(nil).IsVersionFromSameCluster), version1, version2)
  
  195
  >
  }
  
  196
  
  197
  
  // RegisterMetadataChangeCallback mocks base method.

go.temporal.io/server/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/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/util.go 33 covered LOC · 6 ranges

Open complete file

  161
  
  162
  
  // CreatePersistenceClientRetryPolicy creates a retry policy for calls to persistence
  
  163
  >
  func CreatePersistenceClientRetryPolicy() backoff.RetryPolicy {
  
util.go

  164
  >
  	return backoff.NewExponentialRetryPolicy(persistenceClientRetryInitialInterval).
  
  165
  >
  		WithMaximumAttempts(persistenceClientRetryMaxAttempts)
  
  166
  >
  }
  
  167
  
  168
  
  // CreateFrontendClientRetryPolicy creates a retry policy for calls to frontend service

  249
  
  250
  
  // CreateTaskReschedulePolicy creates a retry policy for rescheduling task with errors not equal to ErrTaskRetry
  
  251
  >
  func CreateTaskReschedulePolicy() backoff.RetryPolicy {
  
util.go

  252
  >
  	return backoff.NewExponentialRetryPolicy(taskRescheduleInitialInterval).
  
  253
  >
  		WithBackoffCoefficient(taskRescheduleBackoffCoefficient).
  
  254
  >
  		WithMaximumInterval(taskRescheduleMaxInterval).
  
  255
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  256
  >
  }
  
  257
  
  258
  
  // CreateDependencyTaskNotCompletedReschedulePolicy creates a retry policy for rescheduling task with
  
  259
  
  // ErrDependencyTaskNotCompleted
  
  260
  >
  func CreateDependencyTaskNotCompletedReschedulePolicy() backoff.RetryPolicy {
  
util.go

  261
  >
  	return backoff.NewExponentialRetryPolicy(dependencyTaskNotCompletedRescheduleInitialInterval).
  
  262
  >
  		WithBackoffCoefficient(dependencyTaskNotCompletedRescheduleBackoffCoefficient).
  
  263
  >
  		WithMaximumInterval(dependencyTaskNotCompletedRescheduleMaxInterval).
  
  264
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  265
  >
  }
  
  266
  
  267
  
  // CreateTaskNotReadyReschedulePolicy creates a retry policy for rescheduling task with ErrTaskRetry
  
  268
  >
  func CreateTaskNotReadyReschedulePolicy() backoff.RetryPolicy {
  
util.go

  269
  >
  	return backoff.NewExponentialRetryPolicy(taskNotReadyRescheduleInitialInterval).
  
  270
  >
  		WithBackoffCoefficient(taskNotReadyRescheduleBackoffCoefficient).
  
  271
  >
  		WithMaximumInterval(taskNotReadyRescheduleMaxInterval).
  
  272
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  273
  >
  }
  
  274
  
  275
  
  // CreateTaskResourceExhaustedReschedulePolicy creates a retry policy for rescheduling task with resource exhausted error
  
  276
  >
  func CreateTaskResourceExhaustedReschedulePolicy() backoff.RetryPolicy {
  
util.go

  277
  >
  	return backoff.NewExponentialRetryPolicy(taskResourceExhaustedRescheduleInitialInterval).
  
  278
  >
  		WithBackoffCoefficient(taskResourceExhaustedRescheduleBackoffCoefficient).
  
  279
  >
  		WithMaximumInterval(taskResourceExhaustedRescheduleMaxInterval).
  
  280
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  281
  >
  }
  
  282
  
  283
  
  // CreateSdkClientFactoryRetryPolicy creates a retry policy to handle SdkClientFactory NewClient when frontend service is not ready

  420
  
  	workflowID string,
  
  421
  
  	numberOfShards int32,
  
  422
  >
  ) int32 {
  
util.go

  423
  >
  	idBytes := []byte(namespaceID + "_" + workflowID)
  
  424
  >
  	hash := farm.Fingerprint32(idBytes)
  
  425
  >
  	return int32(hash%uint32(numberOfShards)) + 1 // ShardID starts with 1
  
  426
  >
  }
  
  427
  
  428
  
  func MapShardID(

go.temporal.io/server/api/history/v1/message.pb.go 32 covered LOC · 8 ranges

Open complete file

  92
  
  func (*VersionHistoryItem) ProtoMessage() {}
  
  93
  
  94
  >
  func (x *VersionHistoryItem) ProtoReflect() protoreflect.Message {
  
message.pb.go

  95
  >
  	mi := &file_temporal_server_api_history_v1_message_proto_msgTypes[1]
  
  96
  >
  	if x != nil {
  
  97
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  98
  
  		if ms.LoadMessageInfo() == nil {

  101
  
  		return ms
  
  102
  
  	}
  
  103
  >
  	return mi.MessageOf(x)
  
message.pb.go

  104
  
  }
  
  105

  145
  
  func (*VersionHistory) ProtoMessage() {}
  
  146
  
  147
  >
  func (x *VersionHistory) ProtoReflect() protoreflect.Message {
  
message.pb.go

  148
  >
  	mi := &file_temporal_server_api_history_v1_message_proto_msgTypes[2]
  
  149
  >
  	if x != nil {
  
  150
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  151
  
  		if ms.LoadMessageInfo() == nil {

  154
  
  		return ms
  
  155
  
  	}
  
  156
  >
  	return mi.MessageOf(x)
  
message.pb.go

  157
  
  }
  
  158

  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

  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/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/common/persistence/serialization/codec.go 32 covered LOC · 14 ranges

Open complete file

  26
  
  // encodingTypeFromEnv returns an EncodingType based on the environment variable `TEMPORAL_TEST_DATA_ENCODING`.
  
  27
  
  // It defaults to "ENCODING_TYPE_PROTO3" codec if the environment variable is not set.
  
  28
  >
  func encodingTypeFromEnv() enumspb.EncodingType {
  
codec.go

  29
  >
  	codecType := os.Getenv(SerializerDataEncodingEnvVar)
  
  30
  >
  	switch strings.ToLower(codecType) {
  
  31
  >
  	case "", "proto3":
  
codec.go

  32
  >
  		return enumspb.ENCODING_TYPE_PROTO3
  
  33
  
  	case "json":
  
  34
  
  		return enumspb.ENCODING_TYPE_JSON

  51
  
  // a reliable equality check for any well-formed proto message. For messages
  
  52
  
  // without map fields this is a no-op with no performance overhead.
  
  53
  >
  var WithDeterministicProto3 EncodeOption = func(opts *encodeOptions) {
  
codec.go

  54
  >
  	opts.deterministic = true
  
  55
  >
  }
  
  56
  
  57
  
  // Encode encodes the given proto message. It respects the `TEMPORAL_TEST_DATA_ENCODING` environment variable;
  
  58
  
  // otherwise, it defaults to "ENCODING_TYPE_PROTO3".
  
  59
  >
  func Encode(m proto.Message, options ...EncodeOption) (*commonpb.DataBlob, error) {
  
codec.go

  60
  >
  	return encodeBlob(m, encodingTypeFromEnv(), options...)
  
  61
  >
  }
  
  62
  
  63
  
  func encodeBlob(

  65
  
  	encoding enumspb.EncodingType,
  
  66
  
  	options ...EncodeOption,
  
  67
  >
  ) (*commonpb.DataBlob, error) {
  
codec.go

  68
  >
  	opts := encodeOptions{}
  
  69
  >
  	for _, option := range options {
  
  70
  >
  		option(&opts)
  
codec.go

  71
  >
  	}
  
  72
  
  73
  >
  	if m == nil {
  
codec.go

  74
  
  		return &commonpb.DataBlob{
  
  75
  
  			Data:         nil,

  78
  
  	}
  
  79
  
  80
  >
  	switch encoding {
  
codec.go

  81
  
  	case enumspb.ENCODING_TYPE_JSON:
  
  82
  
  		blob, err := codec.NewJSONPBEncoder().Encode(m)

  88
  
  			EncodingType: enumspb.ENCODING_TYPE_JSON,
  
  89
  
  		}, nil
  
  90
  >
  	case enumspb.ENCODING_TYPE_PROTO3:
  
codec.go

  91
  >
  		data, err := proto.MarshalOptions{Deterministic: opts.deterministic}.Marshal(m)
  
  92
  >
  		if err != nil {
  
  93
  
  			return nil, NewSerializationError(enumspb.ENCODING_TYPE_PROTO3, err)
  
  94
  
  		}
  
  95
  >
  		return &commonpb.DataBlob{
  
codec.go

  96
  >
  			EncodingType: enumspb.ENCODING_TYPE_PROTO3,
  
  97
  >
  			Data:         data,
  
  98
  >
  		}, nil
  
  99
  
  	default:
  
  100
  
  		return nil, NewUnknownEncodingTypeError(encoding.String(), enumspb.ENCODING_TYPE_JSON, enumspb.ENCODING_TYPE_PROTO3)

  102
  
  }
  
  103
  
  104
  >
  func Decode(data *commonpb.DataBlob, result proto.Message) error {
  
codec.go

  105
  >
  	if data == nil {
  
  106
  
  		return NewDeserializationError(enumspb.ENCODING_TYPE_UNSPECIFIED, errors.New("cannot decode nil"))
  
  107
  
  	}
  
  108
  
  109
  >
  	switch data.EncodingType {
  
codec.go

  110
  
  	case enumspb.ENCODING_TYPE_JSON:
  
  111
  
  		return codec.NewJSONPBEncoder().Decode(data.Data, result)
  
  112
  >
  	case enumspb.ENCODING_TYPE_PROTO3:
  
codec.go

  113
  >
  		err := proto.Unmarshal(data.Data, result)
  
  114
  >
  		if err != nil {
  
  115
  
  			return NewDeserializationError(enumspb.ENCODING_TYPE_PROTO3, err)
  
  116
  
  		}
  
  117
  >
  		return nil
  
codec.go

  118
  
  	default:
  
  119
  
  		return NewUnknownEncodingTypeError(data.EncodingType.String(), enumspb.ENCODING_TYPE_JSON, enumspb.ENCODING_TYPE_PROTO3)

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/service/history/historybuilder/history_builder.go 30 covered LOC · 2 ranges

Open complete file

  66
  
  	metricsHandler metrics.Handler,
  
  67
  
  	maxEventBatchSizeInBytes dynamicconfig.IntPropertyFn,
  
  68
  >
  ) *HistoryBuilder {
  
history_builder.go

  69
  >
  	return &HistoryBuilder{
  
  70
  >
  		EventStore: EventStore{
  
  71
  >
  			state:           HistoryBuilderStateMutable,
  
  72
  >
  			timeSource:      timeSource,
  
  73
  >
  			taskIDGenerator: taskIDGenerator,
  
  74
  >
  
  75
  >
  			version:     version,
  
  76
  >
  			nextEventID: nextEventID,
  
  77
  >
  
  78
  >
  			workflowFinished: false,
  
  79
  >
  
  80
  >
  			dbBufferBatch:          dbBufferBatch,
  
  81
  >
  			dbClearBuffer:          false,
  
  82
  >
  			memEventsBatches:       nil,
  
  83
  >
  			memLatestBatch:         nil,
  
  84
  >
  			memBufferBatch:         nil,
  
  85
  >
  			scheduledIDToStartedID: make(map[int64]int64),
  
  86
  >
  			requestIDToEventID:     make(map[string]int64),
  
  87
  >
  
  88
  >
  			maxEventBatchSizeInBytes: maxEventBatchSizeInBytes,
  
  89
  >
  
  90
  >
  			metricsHandler: metricsHandler,
  
  91
  >
  		},
  
  92
  >
  		EventFactory: EventFactory{timeSource: timeSource, version: version},
  
  93
  >
  	}
  
  94
  >
  }
  
  95
  
  96
  
  func (b *HistoryBuilder) SetTimeSource(timeSource clock.TimeSource) {

  153
  
  }
  
  154
  
  155
  >
  func (b *HistoryBuilder) IsDirty() bool {
  
history_builder.go

  156
  >
  	return b.EventStore.IsDirty()
  
  157
  >
  }
  
  158
  
  159
  
  // AddWorkflowExecutionStartedEvent

go.temporal.io/server/api/taskqueue/v1/message.pb.go 29 covered LOC · 2 ranges

Open complete file

  1330
  
  }
  
  1331
  
  1332
  >
  func init() { file_temporal_server_api_taskqueue_v1_message_proto_init() }
  
message.pb.go

  1333
  >
  func file_temporal_server_api_taskqueue_v1_message_proto_init() {
  
  1334
  >
  	if File_temporal_server_api_taskqueue_v1_message_proto != nil {
  
  1335
  
  		return
  
  1336
  
  	}
  
  1337
  >
  	file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0].OneofWrappers = []any{
  
message.pb.go

  1338
  >
  		(*TaskVersionDirective_UseAssignmentRules)(nil),
  
  1339
  >
  		(*TaskVersionDirective_AssignedBuildId)(nil),
  
  1340
  >
  	}
  
  1341
  >
  	file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5].OneofWrappers = []any{
  
  1342
  >
  		(*TaskQueuePartition_NormalPartitionId)(nil),
  
  1343
  >
  		(*TaskQueuePartition_StickyName)(nil),
  
  1344
  >
  		(*TaskQueuePartition_WorkerCommands)(nil),
  
  1345
  >
  	}
  
  1346
  >
  	type x struct{}
  
  1347
  >
  	out := protoimpl.TypeBuilder{
  
  1348
  >
  		File: protoimpl.DescBuilder{
  
  1349
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1350
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc), len(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc)),
  
  1351
  >
  			NumEnums:      0,
  
  1352
  >
  			NumMessages:   16,
  
  1353
  >
  			NumExtensions: 0,
  
  1354
  >
  			NumServices:   0,
  
  1355
  >
  		},
  
  1356
  >
  		GoTypes:           file_temporal_server_api_taskqueue_v1_message_proto_goTypes,
  
  1357
  >
  		DependencyIndexes: file_temporal_server_api_taskqueue_v1_message_proto_depIdxs,
  
  1358
  >
  		MessageInfos:      file_temporal_server_api_taskqueue_v1_message_proto_msgTypes,
  
  1359
  >
  	}.Build()
  
  1360
  >
  	File_temporal_server_api_taskqueue_v1_message_proto = out.File
  
  1361
  >
  	file_temporal_server_api_taskqueue_v1_message_proto_goTypes = nil
  
  1362
  >
  	file_temporal_server_api_taskqueue_v1_message_proto_depIdxs = nil
  
  1363
  
  }

go.temporal.io/server/api/clock/v1/message.pb.go 28 covered LOC · 5 ranges

Open complete file

  45
  
  func (*VectorClock) ProtoMessage() {}
  
  46
  
  47
  >
  func (x *VectorClock) ProtoReflect() protoreflect.Message {
  
message.pb.go

  48
  >
  	mi := &file_temporal_server_api_clock_v1_message_proto_msgTypes[0]
  
  49
  >
  	if x != nil {
  
  50
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  51
  
  		if ms.LoadMessageInfo() == nil {

  54
  
  		return ms
  
  55
  
  	}
  
  56
  >
  	return mi.MessageOf(x)
  
message.pb.go

  57
  
  }
  
  58

  69
  
  }
  
  70
  
  71
  >
  func (x *VectorClock) GetClock() int64 {
  
message.pb.go

  72
  >
  	if x != nil {
  
  73
  >
  		return x.Clock
  
  74
  >
  	}
  
  75
  
  	return 0
  
  76
  
  }

  193
  
  }
  
  194
  
  195
  >
  func init() { file_temporal_server_api_clock_v1_message_proto_init() }
  
message.pb.go

  196
  >
  func file_temporal_server_api_clock_v1_message_proto_init() {
  
  197
  >
  	if File_temporal_server_api_clock_v1_message_proto != nil {
  
  198
  
  		return
  
  199
  
  	}
  
  200
  >
  	type x struct{}
  
message.pb.go

  201
  >
  	out := protoimpl.TypeBuilder{
  
  202
  >
  		File: protoimpl.DescBuilder{
  
  203
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  204
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_clock_v1_message_proto_rawDesc), len(file_temporal_server_api_clock_v1_message_proto_rawDesc)),
  
  205
  >
  			NumEnums:      0,
  
  206
  >
  			NumMessages:   2,
  
  207
  >
  			NumExtensions: 0,
  
  208
  >
  			NumServices:   0,
  
  209
  >
  		},
  
  210
  >
  		GoTypes:           file_temporal_server_api_clock_v1_message_proto_goTypes,
  
  211
  >
  		DependencyIndexes: file_temporal_server_api_clock_v1_message_proto_depIdxs,
  
  212
  >
  		MessageInfos:      file_temporal_server_api_clock_v1_message_proto_msgTypes,
  
  213
  >
  	}.Build()
  
  214
  >
  	File_temporal_server_api_clock_v1_message_proto = out.File
  
  215
  >
  	file_temporal_server_api_clock_v1_message_proto_goTypes = nil
  
  216
  >
  	file_temporal_server_api_clock_v1_message_proto_depIdxs = nil
  
  217
  
  }

go.temporal.io/server/client/client_bean_mock.go 28 covered LOC · 7 ranges

Open complete file

  34
  
  35
  
  // NewMockBean creates a new mock instance.
  
  36
  >
  func NewMockBean(ctrl *gomock.Controller) *MockBean {
  
client_bean_mock.go

  37
  >
  	mock := &MockBean{ctrl: ctrl}
  
  38
  >
  	mock.recorder = &MockBeanMockRecorder{mock}
  
  39
  >
  	return mock
  
  40
  >
  }
  
  41
  
  42
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  43
  >
  func (m *MockBean) EXPECT() *MockBeanMockRecorder {
  
client_bean_mock.go

  44
  >
  	return m.recorder
  
  45
  >
  }
  
  46
  
  47
  
  // Close mocks base method.

  66
  
  67
  
  // GetFrontendClient indicates an expected call of GetFrontendClient.
  
  68
  >
  func (mr *MockBeanMockRecorder) GetFrontendClient() *gomock.Call {
  
client_bean_mock.go

  69
  >
  	mr.mock.ctrl.T.Helper()
  
  70
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFrontendClient", reflect.TypeOf((*MockBean)(nil).GetFrontendClient))
  
  71
  >
  }
  
  72
  
  73
  
  // GetHistoryClient mocks base method.

  80
  
  81
  
  // GetHistoryClient indicates an expected call of GetHistoryClient.
  
  82
  >
  func (mr *MockBeanMockRecorder) GetHistoryClient() *gomock.Call {
  
client_bean_mock.go

  83
  >
  	mr.mock.ctrl.T.Helper()
  
  84
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryClient", reflect.TypeOf((*MockBean)(nil).GetHistoryClient))
  
  85
  >
  }
  
  86
  
  87
  
  // GetMatchingClient mocks base method.

  95
  
  96
  
  // GetMatchingClient indicates an expected call of GetMatchingClient.
  
  97
  >
  func (mr *MockBeanMockRecorder) GetMatchingClient(namespaceIDToName any) *gomock.Call {
  
client_bean_mock.go

  98
  >
  	mr.mock.ctrl.T.Helper()
  
  99
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMatchingClient", reflect.TypeOf((*MockBean)(nil).GetMatchingClient), namespaceIDToName)
  
  100
  >
  }
  
  101
  
  102
  
  // GetRemoteAdminClient mocks base method.

  110
  
  111
  
  // GetRemoteAdminClient indicates an expected call of GetRemoteAdminClient.
  
  112
  >
  func (mr *MockBeanMockRecorder) GetRemoteAdminClient(arg0 any) *gomock.Call {
  
client_bean_mock.go

  113
  >
  	mr.mock.ctrl.T.Helper()
  
  114
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteAdminClient", reflect.TypeOf((*MockBean)(nil).GetRemoteAdminClient), arg0)
  
  115
  >
  }
  
  116
  
  117
  
  // GetRemoteFrontendClient mocks base method.

  126
  
  127
  
  // GetRemoteFrontendClient indicates an expected call of GetRemoteFrontendClient.
  
  128
  >
  func (mr *MockBeanMockRecorder) GetRemoteFrontendClient(arg0 any) *gomock.Call {
  
client_bean_mock.go

  129
  >
  	mr.mock.ctrl.T.Helper()
  
  130
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteFrontendClient", reflect.TypeOf((*MockBean)(nil).GetRemoteFrontendClient), arg0)
  
  131
  >
  }

go.temporal.io/server/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/tree.go 27 covered LOC · 6 ranges

Open complete file

  204
  
  	children map[string]*persistencespb.StateMachineMap,
  
  205
  
  	backend NodeBackend,
  
  206
  >
  ) (*Node, error) {
  
tree.go

  207
  >
  	def, ok := registry.Machine(t)
  
  208
  >
  	if !ok {
  
  209
  
  		return nil, fmt.Errorf("%w: state machine for type: %v", ErrNotRegistered, t)
  
  210
  
  	}
  
  211
  >
  	serialized, err := def.Serialize(data)
  
tree.go

  212
  >
  	if err != nil {
  
  213
  
  		return nil, err
  
  214
  
  	}
  
  215
  >
  	return &Node{
  
tree.go

  216
  >
  		definition: def,
  
  217
  >
  		registry:   registry,
  
  218
  >
  		persistence: &persistencespb.StateMachineNode{
  
  219
  >
  			Children:                      children,
  
  220
  >
  			Data:                          serialized,
  
  221
  >
  			InitialVersionedTransition:    &persistencespb.VersionedTransition{},
  
  222
  >
  			LastUpdateVersionedTransition: &persistencespb.VersionedTransition{},
  
  223
  >
  			TransitionCount:               0,
  
  224
  >
  		},
  
  225
  >
  		cache: &cachedMachine{
  
  226
  >
  			dataLoaded: true,
  
  227
  >
  			data:       data,
  
  228
  >
  			children:   make(map[Key]*Node),
  
  229
  >
  		},
  
  230
  >
  		backend: backend,
  
  231
  >
  		opLog:   make(OperationLog, 0),
  
  232
  >
  	}, nil
  
  233
  
  }
  
  234
  
  235
  
  // Dirty returns true if any of the tree's state machines have transitioned.
  
  236
  >
  func (n *Node) Dirty() bool {
  
tree.go

  237
  >
  	if n.cache.dirty {
  
  238
  
  		return true
  
  239
  
  	}
  
  240
  >
  	for _, child := range n.cache.children {
  
tree.go

  241
  
  		if child.Dirty() {
  
  242
  
  			return true
  
  243
  
  		}
  
  244
  
  	}
  
  245
  >
  	return false
  
tree.go

  246
  
  }
  
  247

go.temporal.io/server/service/history/workflow/transaction_impl.go 27 covered LOC · 3 ranges

Open complete file

  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

  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

go.temporal.io/server/api/enums/v1/common.pb.go 26 covered LOC · 4 ranges

Open complete file

  120
  
  }
  
  121
  
  122
  >
  func (ChecksumFlavor) Descriptor() protoreflect.EnumDescriptor {
  
common.pb.go

  123
  >
  	return file_temporal_server_api_enums_v1_common_proto_enumTypes[1].Descriptor()
  
  124
  >
  }
  
  125
  
  126
  
  func (ChecksumFlavor) Type() protoreflect.EnumType {

  201
  
  }
  
  202
  
  203
  >
  func (CallbackState) Descriptor() protoreflect.EnumDescriptor {
  
common.pb.go

  204
  >
  	return file_temporal_server_api_enums_v1_common_proto_enumTypes[2].Descriptor()
  
  205
  >
  }
  
  206
  
  207
  
  func (CallbackState) Type() protoreflect.EnumType {

  264
  
  }
  
  265
  
  266
  >
  func init() { file_temporal_server_api_enums_v1_common_proto_init() }
  
common.pb.go

  267
  >
  func file_temporal_server_api_enums_v1_common_proto_init() {
  
  268
  >
  	if File_temporal_server_api_enums_v1_common_proto != nil {
  
  269
  
  		return
  
  270
  
  	}
  
  271
  >
  	type x struct{}
  
common.pb.go

  272
  >
  	out := protoimpl.TypeBuilder{
  
  273
  >
  		File: protoimpl.DescBuilder{
  
  274
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  275
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_common_proto_rawDesc), len(file_temporal_server_api_enums_v1_common_proto_rawDesc)),
  
  276
  >
  			NumEnums:      3,
  
  277
  >
  			NumMessages:   0,
  
  278
  >
  			NumExtensions: 0,
  
  279
  >
  			NumServices:   0,
  
  280
  >
  		},
  
  281
  >
  		GoTypes:           file_temporal_server_api_enums_v1_common_proto_goTypes,
  
  282
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_common_proto_depIdxs,
  
  283
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_common_proto_enumTypes,
  
  284
  >
  	}.Build()
  
  285
  >
  	File_temporal_server_api_enums_v1_common_proto = out.File
  
  286
  >
  	file_temporal_server_api_enums_v1_common_proto_goTypes = nil
  
  287
  >
  	file_temporal_server_api_enums_v1_common_proto_depIdxs = nil
  
  288
  
  }

go.temporal.io/server/api/enums/v1/task.pb.go 26 covered LOC · 4 ranges

Open complete file

  303
  
  }
  
  304
  
  305
  >
  func (TaskType) Descriptor() protoreflect.EnumDescriptor {
  
task.pb.go

  306
  >
  	return file_temporal_server_api_enums_v1_task_proto_enumTypes[1].Descriptor()
  
  307
  >
  }
  
  308
  
  309
  
  func (TaskType) Type() protoreflect.EnumType {

  361
  
  }
  
  362
  
  363
  >
  func (TaskPriority) Descriptor() protoreflect.EnumDescriptor {
  
task.pb.go

  364
  >
  	return file_temporal_server_api_enums_v1_task_proto_enumTypes[2].Descriptor()
  
  365
  >
  }
  
  366
  
  367
  
  func (TaskPriority) Type() protoreflect.EnumType {

  456
  
  }
  
  457
  
  458
  >
  func init() { file_temporal_server_api_enums_v1_task_proto_init() }
  
task.pb.go

  459
  >
  func file_temporal_server_api_enums_v1_task_proto_init() {
  
  460
  >
  	if File_temporal_server_api_enums_v1_task_proto != nil {
  
  461
  
  		return
  
  462
  
  	}
  
  463
  >
  	type x struct{}
  
task.pb.go

  464
  >
  	out := protoimpl.TypeBuilder{
  
  465
  >
  		File: protoimpl.DescBuilder{
  
  466
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  467
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_task_proto_rawDesc), len(file_temporal_server_api_enums_v1_task_proto_rawDesc)),
  
  468
  >
  			NumEnums:      3,
  
  469
  >
  			NumMessages:   0,
  
  470
  >
  			NumExtensions: 0,
  
  471
  >
  			NumServices:   0,
  
  472
  >
  		},
  
  473
  >
  		GoTypes:           file_temporal_server_api_enums_v1_task_proto_goTypes,
  
  474
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_task_proto_depIdxs,
  
  475
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_task_proto_enumTypes,
  
  476
  >
  	}.Build()
  
  477
  >
  	File_temporal_server_api_enums_v1_task_proto = out.File
  
  478
  >
  	file_temporal_server_api_enums_v1_task_proto_goTypes = nil
  
  479
  >
  	file_temporal_server_api_enums_v1_task_proto_depIdxs = nil
  
  480
  
  }

go.temporal.io/server/api/enums/v1/workflow.pb.go 26 covered LOC · 4 ranges

Open complete file

  86
  
  }
  
  87
  
  88
  >
  func (WorkflowExecutionState) Descriptor() protoreflect.EnumDescriptor {
  
workflow.pb.go

  89
  >
  	return file_temporal_server_api_enums_v1_workflow_proto_enumTypes[0].Descriptor()
  
  90
  >
  }
  
  91
  
  92
  
  func (WorkflowExecutionState) Type() protoreflect.EnumType {

  150
  
  }
  
  151
  
  152
  >
  func (WorkflowBackoffType) Descriptor() protoreflect.EnumDescriptor {
  
workflow.pb.go

  153
  >
  	return file_temporal_server_api_enums_v1_workflow_proto_enumTypes[1].Descriptor()
  
  154
  >
  }
  
  155
  
  156
  
  func (WorkflowBackoffType) Type() protoreflect.EnumType {

  275
  
  }
  
  276
  
  277
  >
  func init() { file_temporal_server_api_enums_v1_workflow_proto_init() }
  
workflow.pb.go

  278
  >
  func file_temporal_server_api_enums_v1_workflow_proto_init() {
  
  279
  >
  	if File_temporal_server_api_enums_v1_workflow_proto != nil {
  
  280
  
  		return
  
  281
  
  	}
  
  282
  >
  	type x struct{}
  
workflow.pb.go

  283
  >
  	out := protoimpl.TypeBuilder{
  
  284
  >
  		File: protoimpl.DescBuilder{
  
  285
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  286
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_proto_rawDesc)),
  
  287
  >
  			NumEnums:      3,
  
  288
  >
  			NumMessages:   0,
  
  289
  >
  			NumExtensions: 0,
  
  290
  >
  			NumServices:   0,
  
  291
  >
  		},
  
  292
  >
  		GoTypes:           file_temporal_server_api_enums_v1_workflow_proto_goTypes,
  
  293
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_workflow_proto_depIdxs,
  
  294
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_workflow_proto_enumTypes,
  
  295
  >
  	}.Build()
  
  296
  >
  	File_temporal_server_api_enums_v1_workflow_proto = out.File
  
  297
  >
  	file_temporal_server_api_enums_v1_workflow_proto_goTypes = nil
  
  298
  >
  	file_temporal_server_api_enums_v1_workflow_proto_depIdxs = nil
  
  299
  
  }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/message.pb.go 26 covered LOC · 1 range

Open complete file

  843
  
  }
  
  844
  
  845
  >
  func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init() }
  
message.pb.go

  846
  >
  func file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init() {
  
  847
  >
  	if File_temporal_server_chasm_lib_scheduler_proto_v1_message_proto != nil {
  
  848
  >
  		return
  
  849
  >
  	}
  
  850
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_msgTypes[4].OneofWrappers = []any{
  
  851
  >
  		(*BackfillerState_BackfillRequest)(nil),
  
  852
  >
  		(*BackfillerState_TriggerRequest)(nil),
  
  853
  >
  	}
  
  854
  >
  	type x struct{}
  
  855
  >
  	out := protoimpl.TypeBuilder{
  
  856
  >
  		File: protoimpl.DescBuilder{
  
  857
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  858
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_rawDesc)),
  
  859
  >
  			NumEnums:      0,
  
  860
  >
  			NumMessages:   12,
  
  861
  >
  			NumExtensions: 0,
  
  862
  >
  			NumServices:   0,
  
  863
  >
  		},
  
  864
  >
  		GoTypes:           file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_goTypes,
  
  865
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_depIdxs,
  
  866
  >
  		MessageInfos:      file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_msgTypes,
  
  867
  >
  	}.Build()
  
  868
  >
  	File_temporal_server_chasm_lib_scheduler_proto_v1_message_proto = out.File
  
  869
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_goTypes = nil
  
  870
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_depIdxs = nil
  
  871
  
  }

go.temporal.io/server/common/membership/interfaces_mock.go 26 covered LOC · 6 ranges

Open complete file

  32
  
  33
  
  // NewMockMonitor creates a new mock instance.
  
  34
  >
  func NewMockMonitor(ctrl *gomock.Controller) *MockMonitor {
  
interfaces_mock.go

  35
  >
  	mock := &MockMonitor{ctrl: ctrl}
  
  36
  >
  	mock.recorder = &MockMonitorMockRecorder{mock}
  
  37
  >
  	return mock
  
  38
  >
  }
  
  39
  
  40
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  41
  >
  func (m *MockMonitor) EXPECT() *MockMonitorMockRecorder {
  
interfaces_mock.go

  42
  >
  	return m.recorder
  
  43
  >
  }
  
  44
  
  45
  
  // ApproximateMaxPropagationTime mocks base method.

  111
  
  112
  
  // GetResolver indicates an expected call of GetResolver.
  
  113
  >
  func (mr *MockMonitorMockRecorder) GetResolver(service any) *gomock.Call {
  
interfaces_mock.go

  114
  >
  	mr.mock.ctrl.T.Helper()
  
  115
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResolver", reflect.TypeOf((*MockMonitor)(nil).GetResolver), service)
  
  116
  >
  }
  
  117
  
  118
  
  // SetDraining mocks base method.

  151
  
  152
  
  // WaitUntilInitialized indicates an expected call of WaitUntilInitialized.
  
  153
  >
  func (mr *MockMonitorMockRecorder) WaitUntilInitialized(arg0 any) *gomock.Call {
  
interfaces_mock.go

  154
  >
  	mr.mock.ctrl.T.Helper()
  
  155
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInitialized", reflect.TypeOf((*MockMonitor)(nil).WaitUntilInitialized), arg0)
  
  156
  >
  }
  
  157
  
  158
  
  // MockServiceResolver is a mock of ServiceResolver interface.

  169
  
  170
  
  // NewMockServiceResolver creates a new mock instance.
  
  171
  >
  func NewMockServiceResolver(ctrl *gomock.Controller) *MockServiceResolver {
  
interfaces_mock.go

  172
  >
  	mock := &MockServiceResolver{ctrl: ctrl}
  
  173
  >
  	mock.recorder = &MockServiceResolverMockRecorder{mock}
  
  174
  >
  	return mock
  
  175
  >
  }
  
  176
  
  177
  
  // EXPECT returns an object that allows the caller to indicate expected use.

  318
  
  319
  
  // NewMockHostInfoProvider creates a new mock instance.
  
  320
  >
  func NewMockHostInfoProvider(ctrl *gomock.Controller) *MockHostInfoProvider {
  
interfaces_mock.go

  321
  >
  	mock := &MockHostInfoProvider{ctrl: ctrl}
  
  322
  >
  	mock.recorder = &MockHostInfoProviderMockRecorder{mock}
  
  323
  >
  	return mock
  
  324
  >
  }
  
  325
  
  326
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/activity_state.pb.go 25 covered LOC · 2 ranges

Open complete file

  1382
  
  }
  
  1383
  
  1384
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_init() }
  
activity_state.pb.go

  1385
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_init() {
  
  1386
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto != nil {
  
  1387
  
  		return
  
  1388
  
  	}
  
  1389
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_msgTypes[7].OneofWrappers = []any{
  
activity_state.pb.go

  1390
  >
  		(*ActivityOutcome_Successful_)(nil),
  
  1391
  >
  		(*ActivityOutcome_Failed_)(nil),
  
  1392
  >
  	}
  
  1393
  >
  	type x struct{}
  
  1394
  >
  	out := protoimpl.TypeBuilder{
  
  1395
  >
  		File: protoimpl.DescBuilder{
  
  1396
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1397
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_rawDesc)),
  
  1398
  >
  			NumEnums:      2,
  
  1399
  >
  			NumMessages:   11,
  
  1400
  >
  			NumExtensions: 0,
  
  1401
  >
  			NumServices:   0,
  
  1402
  >
  		},
  
  1403
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_goTypes,
  
  1404
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_depIdxs,
  
  1405
  >
  		EnumInfos:         file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_enumTypes,
  
  1406
  >
  		MessageInfos:      file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_msgTypes,
  
  1407
  >
  	}.Build()
  
  1408
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto = out.File
  
  1409
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_goTypes = nil
  
  1410
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_depIdxs = nil
  
  1411
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/operation.pb.go 25 covered LOC · 2 ranges

Open complete file

  998
  
  }
  
  999
  
  1000
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_init() }
  
operation.pb.go

  1001
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_init() {
  
  1002
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto != nil {
  
  1003
  
  		return
  
  1004
  
  	}
  
  1005
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_msgTypes[2].OneofWrappers = []any{
  
operation.pb.go

  1006
  >
  		(*OperationOutcome_Successful_)(nil),
  
  1007
  >
  		(*OperationOutcome_Failed_)(nil),
  
  1008
  >
  	}
  
  1009
  >
  	type x struct{}
  
  1010
  >
  	out := protoimpl.TypeBuilder{
  
  1011
  >
  		File: protoimpl.DescBuilder{
  
  1012
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1013
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_rawDesc)),
  
  1014
  >
  			NumEnums:      2,
  
  1015
  >
  			NumMessages:   8,
  
  1016
  >
  			NumExtensions: 0,
  
  1017
  >
  			NumServices:   0,
  
  1018
  >
  		},
  
  1019
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_goTypes,
  
  1020
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_depIdxs,
  
  1021
  >
  		EnumInfos:         file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_enumTypes,
  
  1022
  >
  		MessageInfos:      file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_msgTypes,
  
  1023
  >
  	}.Build()
  
  1024
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto = out.File
  
  1025
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_goTypes = nil
  
  1026
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_operation_proto_depIdxs = nil
  
  1027
  
  }

go.temporal.io/server/common/persistence/transitionhistory/transition_history.go 25 covered LOC · 9 ranges

Open complete file

  34
  
  func LastVersionedTransition(
  
  35
  
  	transitions []*persistencespb.VersionedTransition,
  
  36
  >
  ) *persistencespb.VersionedTransition {
  
transition_history.go

  37
  >
  	if len(transitions) == 0 {
  
  38
  >
  		// transition history is not enabled
  
transition_history.go

  39
  >
  		return nil
  
  40
  >
  	}
  
  41
  >
  	return transitions[len(transitions)-1]
  
transition_history.go

  42
  
  }
  
  43

  82
  
  	history []*persistencespb.VersionedTransition,
  
  83
  
  	refVersionedTransition *persistencespb.VersionedTransition,
  
  84
  >
  ) error {
  
transition_history.go

  85
  >
  	if len(history) == 0 {
  
  86
  
  		return serviceerror.NewInternal("state has empty transition history")
  
  87
  
  	}
  
  88
  >
  	idx, minTransitionCount, maxTransitionCount := transitionHistoryRangeForVersion(history, refVersionedTransition.NamespaceFailoverVersion)
  
transition_history.go

  89
  >
  	if idx == -1 {
  
  90
  >
  		lastItem := history[len(history)-1]
  
transition_history.go

  91
  >
  		if lastItem.NamespaceFailoverVersion < refVersionedTransition.NamespaceFailoverVersion {
  
  92
  >
  			return fmt.Errorf(
  
  93
  >
  				"%w: state namespace failover version < ref namespace failover version: %v < %v",
  
  94
  >
  				consts.ErrStaleState,
  
  95
  >
  				lastItem.NamespaceFailoverVersion,
  
  96
  >
  				refVersionedTransition.NamespaceFailoverVersion,
  
  97
  >
  			)
  
  98
  >
  		}
  
  99
  
  		return fmt.Errorf(
  
  100
  
  			"%w: state namespace failover version > ref namespace failover version: %v > %v",

  129
  
  	history []*persistencespb.VersionedTransition,
  
  130
  
  	version int64,
  
  131
  >
  ) (idx int, minTransitionCount int64, maxTransitionCount int64) {
  
transition_history.go

  132
  >
  	prevVersionMaxTransitionCount := int64(-1)
  
  133
  >
  	for i, item := range history {
  
  134
  >
  		if item.NamespaceFailoverVersion == version {
  
  135
  
  			return i, prevVersionMaxTransitionCount + 1, item.TransitionCount
  
  136
  
  		}
  
  137
  >
  		prevVersionMaxTransitionCount = item.TransitionCount
  
transition_history.go

  138
  
  	}
  
  139
  >
  	return -1, 0, 0
  
transition_history.go

  140
  
  }

go.temporal.io/server/common/routing/route.go 25 covered LOC · 8 ranges

Open complete file

  36
  
  37
  
  // NewRoute returns a new [Route] instance with the given components.
  
  38
  >
  func NewRoute[T any](components ...Component[T]) Route[T] {
  
route.go

  39
  >
  	return Route[T]{components: components}
  
  40
  >
  }
  
  41
  
  42
  
  // RouteBuilder is a builder for the [Route] interface.

  46
  
  47
  
  // NewBuilder creates a new [RouteBuilder] instance, which can be used to define a new [Route] via a fluent API.
  
  48
  >
  func NewBuilder[T any]() *RouteBuilder[T] {
  
route.go

  49
  >
  	return &RouteBuilder[T]{}
  
  50
  >
  }
  
  51
  
  52
  
  // With adds a series of [Component] instances to the [Route].
  
  53
  >
  func (r *RouteBuilder[T]) With(c ...Component[T]) *RouteBuilder[T] {
  
route.go

  54
  >
  	r.components = append(r.components, c...)
  
  55
  >
  	return r
  
  56
  >
  }
  
  57
  
  58
  
  // Constant adds a [Constant] component to the [Route].
  
  59
  >
  func (r *RouteBuilder[T]) Constant(values ...string) *RouteBuilder[T] {
  
route.go

  60
  >
  	return r.With(Constant[T](values...))
  
  61
  >
  }
  
  62
  
  63
  
  // StringVariable adds a [StringVariable] component to the [Route].
  
  64
  >
  func (r *RouteBuilder[T]) StringVariable(name string, getter func(*T) *string) *RouteBuilder[T] {
  
route.go

  65
  >
  	return r.With(StringVariable[T](name, getter))
  
  66
  >
  }
  
  67
  
  68
  
  // Build returns a read-only [Route].
  
  69
  >
  func (r *RouteBuilder[T]) Build() Route[T] {
  
route.go

  70
  >
  	return NewRoute[T](r.components...)
  
  71
  >
  }
  
  72
  
  73
  
  // Representation returns the [github.com/gorilla/mux] compatible string representation of the route for usage in a

  111
  
  // Constant returns a [Component] that represents a series of constant HTTP path components in a Route.
  
  112
  
  // They will be joined via strings when used to construct a path or path representation.
  
  113
  >
  func Constant[T any](values ...string) constant[T] {
  
route.go

  114
  >
  	return values
  
  115
  >
  }
  
  116
  
  117
  
  type constant[T any] []string

  128
  
  129
  
  // StringVariable returns a [Component] that represents a string variable in a Route.
  
  130
  >
  func StringVariable[T any](name string, getter func(*T) *string) stringVariable[T] {
  
route.go

  131
  >
  	return stringVariable[T]{name, getter}
  
  132
  >
  }
  
  133
  
  134
  
  type stringVariable[T any] struct {

go.temporal.io/server/api/persistence/v1/nexus.pb.go 24 covered LOC · 2 ranges

Open complete file

  481
  
  }
  
  482
  
  483
  >
  func init() { file_temporal_server_api_persistence_v1_nexus_proto_init() }
  
nexus.pb.go

  484
  >
  func file_temporal_server_api_persistence_v1_nexus_proto_init() {
  
  485
  >
  	if File_temporal_server_api_persistence_v1_nexus_proto != nil {
  
  486
  
  		return
  
  487
  
  	}
  
  488
  >
  	file_temporal_server_api_persistence_v1_nexus_proto_msgTypes[1].OneofWrappers = []any{
  
nexus.pb.go

  489
  >
  		(*NexusEndpointTarget_Worker_)(nil),
  
  490
  >
  		(*NexusEndpointTarget_External_)(nil),
  
  491
  >
  	}
  
  492
  >
  	type x struct{}
  
  493
  >
  	out := protoimpl.TypeBuilder{
  
  494
  >
  		File: protoimpl.DescBuilder{
  
  495
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  496
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_nexus_proto_rawDesc), len(file_temporal_server_api_persistence_v1_nexus_proto_rawDesc)),
  
  497
  >
  			NumEnums:      0,
  
  498
  >
  			NumMessages:   6,
  
  499
  >
  			NumExtensions: 0,
  
  500
  >
  			NumServices:   0,
  
  501
  >
  		},
  
  502
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_nexus_proto_goTypes,
  
  503
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_nexus_proto_depIdxs,
  
  504
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_nexus_proto_msgTypes,
  
  505
  >
  	}.Build()
  
  506
  >
  	File_temporal_server_api_persistence_v1_nexus_proto = out.File
  
  507
  >
  	file_temporal_server_api_persistence_v1_nexus_proto_goTypes = nil
  
  508
  >
  	file_temporal_server_api_persistence_v1_nexus_proto_depIdxs = nil
  
  509
  
  }

go.temporal.io/server/api/persistence/v1/workflow_mutable_state.pb.go 24 covered LOC · 2 ranges

Open complete file

  532
  
  }
  
  533
  
  534
  >
  func init() { file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_init() }
  
workflow_mutable_state.pb.go

  535
  >
  func file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_init() {
  
  536
  >
  	if File_temporal_server_api_persistence_v1_workflow_mutable_state_proto != nil {
  
  537
  
  		return
  
  538
  
  	}
  
  539
  >
  	file_temporal_server_api_persistence_v1_chasm_proto_init()
  
workflow_mutable_state.pb.go

  540
  >
  	file_temporal_server_api_persistence_v1_executions_proto_init()
  
  541
  >
  	file_temporal_server_api_persistence_v1_hsm_proto_init()
  
  542
  >
  	file_temporal_server_api_persistence_v1_update_proto_init()
  
  543
  >
  	type x struct{}
  
  544
  >
  	out := protoimpl.TypeBuilder{
  
  545
  >
  		File: protoimpl.DescBuilder{
  
  546
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  547
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_rawDesc), len(file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_rawDesc)),
  
  548
  >
  			NumEnums:      0,
  
  549
  >
  			NumMessages:   16,
  
  550
  >
  			NumExtensions: 0,
  
  551
  >
  			NumServices:   0,
  
  552
  >
  		},
  
  553
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_goTypes,
  
  554
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_depIdxs,
  
  555
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_msgTypes,
  
  556
  >
  	}.Build()
  
  557
  >
  	File_temporal_server_api_persistence_v1_workflow_mutable_state_proto = out.File
  
  558
  >
  	file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_goTypes = nil
  
  559
  >
  	file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_depIdxs = nil
  
  560
  
  }

go.temporal.io/server/api/schedule/v1/message.pb.go 24 covered LOC · 2 ranges

Open complete file

  1224
  
  }
  
  1225
  
  1226
  >
  func init() { file_temporal_server_api_schedule_v1_message_proto_init() }
  
message.pb.go

  1227
  >
  func file_temporal_server_api_schedule_v1_message_proto_init() {
  
  1228
  >
  	if File_temporal_server_api_schedule_v1_message_proto != nil {
  
  1229
  
  		return
  
  1230
  
  	}
  
  1231
  >
  	file_temporal_server_api_schedule_v1_message_proto_msgTypes[7].OneofWrappers = []any{
  
message.pb.go

  1232
  >
  		(*WatchWorkflowResponse_Result)(nil),
  
  1233
  >
  		(*WatchWorkflowResponse_Failure)(nil),
  
  1234
  >
  	}
  
  1235
  >
  	type x struct{}
  
  1236
  >
  	out := protoimpl.TypeBuilder{
  
  1237
  >
  		File: protoimpl.DescBuilder{
  
  1238
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1239
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_schedule_v1_message_proto_rawDesc), len(file_temporal_server_api_schedule_v1_message_proto_rawDesc)),
  
  1240
  >
  			NumEnums:      0,
  
  1241
  >
  			NumMessages:   13,
  
  1242
  >
  			NumExtensions: 0,
  
  1243
  >
  			NumServices:   0,
  
  1244
  >
  		},
  
  1245
  >
  		GoTypes:           file_temporal_server_api_schedule_v1_message_proto_goTypes,
  
  1246
  >
  		DependencyIndexes: file_temporal_server_api_schedule_v1_message_proto_depIdxs,
  
  1247
  >
  		MessageInfos:      file_temporal_server_api_schedule_v1_message_proto_msgTypes,
  
  1248
  >
  	}.Build()
  
  1249
  >
  	File_temporal_server_api_schedule_v1_message_proto = out.File
  
  1250
  >
  	file_temporal_server_api_schedule_v1_message_proto_goTypes = nil
  
  1251
  >
  	file_temporal_server_api_schedule_v1_message_proto_depIdxs = nil
  
  1252
  
  }

go.temporal.io/server/api/workflow/v1/message.pb.go 24 covered LOC · 4 ranges

Open complete file

  189
  
  func (*BaseExecutionInfo) ProtoMessage() {}
  
  190
  
  191
  >
  func (x *BaseExecutionInfo) ProtoReflect() protoreflect.Message {
  
message.pb.go

  192
  >
  	mi := &file_temporal_server_api_workflow_v1_message_proto_msgTypes[2]
  
  193
  >
  	if x != nil {
  
  194
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  195
  
  		if ms.LoadMessageInfo() == nil {

  198
  
  		return ms
  
  199
  
  	}
  
  200
  >
  	return mi.MessageOf(x)
  
message.pb.go

  201
  
  }
  
  202

  278
  
  }
  
  279
  
  280
  >
  func init() { file_temporal_server_api_workflow_v1_message_proto_init() }
  
message.pb.go

  281
  >
  func file_temporal_server_api_workflow_v1_message_proto_init() {
  
  282
  >
  	if File_temporal_server_api_workflow_v1_message_proto != nil {
  
  283
  
  		return
  
  284
  
  	}
  
  285
  >
  	type x struct{}
  
message.pb.go

  286
  >
  	out := protoimpl.TypeBuilder{
  
  287
  >
  		File: protoimpl.DescBuilder{
  
  288
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  289
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_workflow_v1_message_proto_rawDesc), len(file_temporal_server_api_workflow_v1_message_proto_rawDesc)),
  
  290
  >
  			NumEnums:      0,
  
  291
  >
  			NumMessages:   3,
  
  292
  >
  			NumExtensions: 0,
  
  293
  >
  			NumServices:   0,
  
  294
  >
  		},
  
  295
  >
  		GoTypes:           file_temporal_server_api_workflow_v1_message_proto_goTypes,
  
  296
  >
  		DependencyIndexes: file_temporal_server_api_workflow_v1_message_proto_depIdxs,
  
  297
  >
  		MessageInfos:      file_temporal_server_api_workflow_v1_message_proto_msgTypes,
  
  298
  >
  	}.Build()
  
  299
  >
  	File_temporal_server_api_workflow_v1_message_proto = out.File
  
  300
  >
  	file_temporal_server_api_workflow_v1_message_proto_goTypes = nil
  
  301
  >
  	file_temporal_server_api_workflow_v1_message_proto_depIdxs = nil
  
  302
  
  }

go.temporal.io/server/chasm/lib/callback/gen/callbackpb/v1/message.pb.go 24 covered LOC · 2 ranges

Open complete file

  462
  
  }
  
  463
  
  464
  >
  func init() { file_temporal_server_chasm_lib_callback_proto_v1_message_proto_init() }
  
message.pb.go

  465
  >
  func file_temporal_server_chasm_lib_callback_proto_v1_message_proto_init() {
  
  466
  >
  	if File_temporal_server_chasm_lib_callback_proto_v1_message_proto != nil {
  
  467
  
  		return
  
  468
  
  	}
  
  469
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_message_proto_msgTypes[1].OneofWrappers = []any{
  
message.pb.go

  470
  >
  		(*Callback_Nexus_)(nil),
  
  471
  >
  	}
  
  472
  >
  	type x struct{}
  
  473
  >
  	out := protoimpl.TypeBuilder{
  
  474
  >
  		File: protoimpl.DescBuilder{
  
  475
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  476
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_callback_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_callback_proto_v1_message_proto_rawDesc)),
  
  477
  >
  			NumEnums:      1,
  
  478
  >
  			NumMessages:   5,
  
  479
  >
  			NumExtensions: 0,
  
  480
  >
  			NumServices:   0,
  
  481
  >
  		},
  
  482
  >
  		GoTypes:           file_temporal_server_chasm_lib_callback_proto_v1_message_proto_goTypes,
  
  483
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_callback_proto_v1_message_proto_depIdxs,
  
  484
  >
  		EnumInfos:         file_temporal_server_chasm_lib_callback_proto_v1_message_proto_enumTypes,
  
  485
  >
  		MessageInfos:      file_temporal_server_chasm_lib_callback_proto_v1_message_proto_msgTypes,
  
  486
  >
  	}.Build()
  
  487
  >
  	File_temporal_server_chasm_lib_callback_proto_v1_message_proto = out.File
  
  488
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_message_proto_goTypes = nil
  
  489
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_message_proto_depIdxs = nil
  
  490
  
  }

go.temporal.io/server/chasm/ref.go 24 covered LOC · 7 ranges

Open complete file

  114
  
  func (r *ComponentRef) ArchetypeID(
  
  115
  
  	registry *Registry,
  
  116
  >
  ) (ArchetypeID, error) {
  
ref.go

  117
  >
  	if r.archetypeID != UnspecifiedArchetypeID {
  
  118
  >
  		return r.archetypeID, nil
  
ref.go

  119
  >
  	}
  
  120
  
  121
  
  	rc, ok := registry.componentOf(r.executionGoType)

  154
  
  // DeserializeComponentRef deserializes a byte slice into a ComponentRef.
  
  155
  
  // Provides caller the access to information including ExecutionKey, Archetype, and ShardingKey.
  
  156
  >
  func DeserializeComponentRef(data []byte) (ComponentRef, error) {
  
ref.go

  157
  >
  	if len(data) == 0 {
  
  158
  
  		return ComponentRef{}, ErrInvalidComponentRef
  
  159
  
  	}
  
  160
  >
  	var pRef persistencespb.ChasmComponentRef
  
ref.go

  161
  >
  	if err := pRef.Unmarshal(data); err != nil {
  
  162
  
  		return ComponentRef{}, ErrMalformedComponentRef
  
  163
  
  	}
  
  164
  
  165
  >
  	ref := ProtoRefToComponentRef(&pRef)
  
ref.go

  166
  >
  	if ref.BusinessID == "" || ref.NamespaceID == "" {
  
  167
  
  		return ComponentRef{}, ErrInvalidComponentRef
  
  168
  
  	}
  
  169
  >
  	return ref, nil
  
ref.go

  170
  
  }
  
  171

  173
  
  // ComponentRef. This is useful for situations where the protobuf ComponentRef has
  
  174
  
  // already been deserialized as part of an enclosing message.
  
  175
  >
  func ProtoRefToComponentRef(pRef *persistencespb.ChasmComponentRef) ComponentRef {
  
ref.go

  176
  >
  	return ComponentRef{
  
  177
  >
  		ExecutionKey: ExecutionKey{
  
  178
  >
  			NamespaceID: pRef.NamespaceId,
  
  179
  >
  			BusinessID:  pRef.BusinessId,
  
  180
  >
  			RunID:       pRef.RunId,
  
  181
  >
  		},
  
  182
  >
  		archetypeID:           pRef.ArchetypeId,
  
  183
  >
  		executionLastUpdateVT: pRef.ExecutionVersionedTransition,
  
  184
  >
  		componentPath:         pRef.ComponentPath,
  
  185
  >
  		componentInitialVT:    pRef.ComponentInitialVersionedTransition,
  
  186
  >
  	}
  
  187
  >
  }

go.temporal.io/server/service/history/shard/task_key_manager.go 24 covered LOC · 3 ranges

Open complete file

  28
  
  	logger log.Logger,
  
  29
  
  	renewRangeIDFn renewRangeIDFn,
  
  30
  >
  ) *taskKeyManager {
  
task_key_manager.go

  31
  >
  	return &taskKeyManager{
  
  32
  >
  		generator: newTaskKeyGenerator(
  
  33
  >
  			config.RangeSizeBits,
  
  34
  >
  			timeSource,
  
  35
  >
  			logger,
  
  36
  >
  			renewRangeIDFn,
  
  37
  >
  		),
  
  38
  >
  		tracker:    newTaskRequestTracker(taskCategoryRegistry),
  
  39
  >
  		timeSource: timeSource,
  
  40
  >
  		logger:     logger,
  
  41
  >
  		config:     config,
  
  42
  >
  	}
  
  43
  >
  }
  
  44
  
  45
  
  func (m *taskKeyManager) setAndTrackTaskKeys(

  56
  
  func (m *taskKeyManager) peekTaskKey(
  
  57
  
  	category tasks.Category,
  
  58
  >
  ) tasks.Key {
  
task_key_manager.go

  59
  >
  	return m.generator.peekTaskKey(category)
  
  60
  >
  }
  
  61
  
  62
  
  func (m *taskKeyManager) generateTaskKey(

  72
  
  func (m *taskKeyManager) setRangeID(
  
  73
  
  	rangeID int64,
  
  74
  >
  ) {
  
task_key_manager.go

  75
  >
  	m.generator.setRangeID(rangeID)
  
  76
  >
  
  77
  >
  	// rangeID update means all pending add tasks requests either already succeeded
  
  78
  >
  	// are guaranteed to fail, so we can clear pending requests in the tracker
  
  79
  >
  	m.tracker.clear()
  
  80
  >
  }
  
  81
  
  82
  
  func (m *taskKeyManager) setTaskMinScheduledTime(

go.temporal.io/server/api/enums/v1/nexus.pb.go 23 covered LOC · 3 ranges

Open complete file

  102
  
  }
  
  103
  
  104
  >
  func (NexusOperationState) Descriptor() protoreflect.EnumDescriptor {
  
nexus.pb.go

  105
  >
  	return file_temporal_server_api_enums_v1_nexus_proto_enumTypes[0].Descriptor()
  
  106
  >
  }
  
  107
  
  108
  
  func (NexusOperationState) Type() protoreflect.EnumType {

  158
  
  }
  
  159
  
  160
  >
  func init() { file_temporal_server_api_enums_v1_nexus_proto_init() }
  
nexus.pb.go

  161
  >
  func file_temporal_server_api_enums_v1_nexus_proto_init() {
  
  162
  >
  	if File_temporal_server_api_enums_v1_nexus_proto != nil {
  
  163
  
  		return
  
  164
  
  	}
  
  165
  >
  	type x struct{}
  
nexus.pb.go

  166
  >
  	out := protoimpl.TypeBuilder{
  
  167
  >
  		File: protoimpl.DescBuilder{
  
  168
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  169
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_nexus_proto_rawDesc), len(file_temporal_server_api_enums_v1_nexus_proto_rawDesc)),
  
  170
  >
  			NumEnums:      1,
  
  171
  >
  			NumMessages:   0,
  
  172
  >
  			NumExtensions: 0,
  
  173
  >
  			NumServices:   0,
  
  174
  >
  		},
  
  175
  >
  		GoTypes:           file_temporal_server_api_enums_v1_nexus_proto_goTypes,
  
  176
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_nexus_proto_depIdxs,
  
  177
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_nexus_proto_enumTypes,
  
  178
  >
  	}.Build()
  
  179
  >
  	File_temporal_server_api_enums_v1_nexus_proto = out.File
  
  180
  >
  	file_temporal_server_api_enums_v1_nexus_proto_goTypes = nil
  
  181
  >
  	file_temporal_server_api_enums_v1_nexus_proto_depIdxs = nil
  
  182
  
  }

go.temporal.io/server/api/enums/v1/predicate.pb.go 23 covered LOC · 3 ranges

Open complete file

  111
  
  }
  
  112
  
  113
  >
  func (PredicateType) Descriptor() protoreflect.EnumDescriptor {
  
predicate.pb.go

  114
  >
  	return file_temporal_server_api_enums_v1_predicate_proto_enumTypes[0].Descriptor()
  
  115
  >
  }
  
  116
  
  117
  
  func (PredicateType) Type() protoreflect.EnumType {

  170
  
  }
  
  171
  
  172
  >
  func init() { file_temporal_server_api_enums_v1_predicate_proto_init() }
  
predicate.pb.go

  173
  >
  func file_temporal_server_api_enums_v1_predicate_proto_init() {
  
  174
  >
  	if File_temporal_server_api_enums_v1_predicate_proto != nil {
  
  175
  
  		return
  
  176
  
  	}
  
  177
  >
  	type x struct{}
  
predicate.pb.go

  178
  >
  	out := protoimpl.TypeBuilder{
  
  179
  >
  		File: protoimpl.DescBuilder{
  
  180
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  181
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_predicate_proto_rawDesc), len(file_temporal_server_api_enums_v1_predicate_proto_rawDesc)),
  
  182
  >
  			NumEnums:      1,
  
  183
  >
  			NumMessages:   0,
  
  184
  >
  			NumExtensions: 0,
  
  185
  >
  			NumServices:   0,
  
  186
  >
  		},
  
  187
  >
  		GoTypes:           file_temporal_server_api_enums_v1_predicate_proto_goTypes,
  
  188
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_predicate_proto_depIdxs,
  
  189
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_predicate_proto_enumTypes,
  
  190
  >
  	}.Build()
  
  191
  >
  	File_temporal_server_api_enums_v1_predicate_proto = out.File
  
  192
  >
  	file_temporal_server_api_enums_v1_predicate_proto_goTypes = nil
  
  193
  >
  	file_temporal_server_api_enums_v1_predicate_proto_depIdxs = nil
  
  194
  
  }

go.temporal.io/server/api/enums/v1/workflow_task_type.pb.go 23 covered LOC · 3 ranges

Open complete file

  72
  
  }
  
  73
  
  74
  >
  func (WorkflowTaskType) Descriptor() protoreflect.EnumDescriptor {
  
workflow_task_type.pb.go

  75
  >
  	return file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes[0].Descriptor()
  
  76
  >
  }
  
  77
  
  78
  
  func (WorkflowTaskType) Type() protoreflect.EnumType {

  124
  
  }
  
  125
  
  126
  >
  func init() { file_temporal_server_api_enums_v1_workflow_task_type_proto_init() }
  
workflow_task_type.pb.go

  127
  >
  func file_temporal_server_api_enums_v1_workflow_task_type_proto_init() {
  
  128
  >
  	if File_temporal_server_api_enums_v1_workflow_task_type_proto != nil {
  
  129
  
  		return
  
  130
  
  	}
  
  131
  >
  	type x struct{}
  
workflow_task_type.pb.go

  132
  >
  	out := protoimpl.TypeBuilder{
  
  133
  >
  		File: protoimpl.DescBuilder{
  
  134
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  135
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc)),
  
  136
  >
  			NumEnums:      1,
  
  137
  >
  			NumMessages:   0,
  
  138
  >
  			NumExtensions: 0,
  
  139
  >
  			NumServices:   0,
  
  140
  >
  		},
  
  141
  >
  		GoTypes:           file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes,
  
  142
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs,
  
  143
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes,
  
  144
  >
  	}.Build()
  
  145
  >
  	File_temporal_server_api_enums_v1_workflow_task_type_proto = out.File
  
  146
  >
  	file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes = nil
  
  147
  >
  	file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs = nil
  
  148
  
  }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/request_response.pb.go 23 covered LOC · 1 range

Open complete file

  1021
  
  }
  
  1022
  
  1023
  >
  func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init() }
  
request_response.pb.go

  1024
  >
  func file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init() {
  
  1025
  >
  	if File_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto != nil {
  
  1026
  >
  		return
  
  1027
  >
  	}
  
  1028
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_message_proto_init()
  
  1029
  >
  	type x struct{}
  
  1030
  >
  	out := protoimpl.TypeBuilder{
  
  1031
  >
  		File: protoimpl.DescBuilder{
  
  1032
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1033
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_rawDesc)),
  
  1034
  >
  			NumEnums:      0,
  
  1035
  >
  			NumMessages:   18,
  
  1036
  >
  			NumExtensions: 0,
  
  1037
  >
  			NumServices:   0,
  
  1038
  >
  		},
  
  1039
  >
  		GoTypes:           file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_goTypes,
  
  1040
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_depIdxs,
  
  1041
  >
  		MessageInfos:      file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_msgTypes,
  
  1042
  >
  	}.Build()
  
  1043
  >
  	File_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto = out.File
  
  1044
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_goTypes = nil
  
  1045
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_depIdxs = nil
  
  1046
  
  }

go.temporal.io/server/common/dynamicconfig/shared_structure.go 23 covered LOC · 6 ranges

Open complete file

  17
  
  )
  
  18
  
  19
  >
  func warnDefaultSharedStructure(key string, def any) {
  
shared_structure.go

  20
  >
  	if path := hasSharedStructure(reflect.ValueOf(def), "root"); path != "" {
  
  21
  
  		sharedStructureWarnings.Store(key, path)
  
  22
  
  	}
  
  23
  
  }
  
  24
  
  25
  >
  func logSharedStructureWarnings(logger log.Logger) {
  
shared_structure.go

  26
  >
  	// If you see this warning, it means that a default value used in New*TypedSetting has a
  
  27
  >
  	// non-nil slice or map in it. That can lead to confusing behavior since the value from
  
  28
  >
  	// dynamic config will be merged over the default value (e.g. the slice will be appended
  
  29
  >
  	// to, not replaced). If that behavior is desired, you can avoid this warning by using
  
  30
  >
  	// New*TypedSettingWithConverter and referring to dynamicconfig.ConvertStructure
  
  31
  >
  	// explicitly. Otherwise use nil slices and maps, including at the top level
  
  32
  >
  	// (so `[]string(nil)` instead of `[]string{}`).
  
  33
  >
  	logSharedStructureWarningsOnce.Do(func() {
  
  34
  >
  		sharedStructureWarnings.Range(func(key, path any) bool {
  
  35
  
  			softassert.Fail(logger,
  
  36
  
  				"default value contains shared structure",

  42
  
  }
  
  43
  
  44
  >
  func hasSharedStructure(v reflect.Value, path string) string {
  
shared_structure.go

  45
  >
  	// nolint:exhaustive // deliberately not exhaustive
  
  46
  >
  	switch v.Kind() {
  
  47
  >
  	case reflect.Map, reflect.Slice, reflect.Pointer:
  
  48
  >
  		if !v.IsNil() {
  
  49
  
  			return path
  
  50
  
  		}
  
  51
  >
  	case reflect.Interface:
  
shared_structure.go

  52
  >
  		if !v.IsNil() {
  
  53
  
  			return hasSharedStructure(v.Elem(), path)
  
  54
  
  		}
  
  55
  >
  	case reflect.Struct:
  
shared_structure.go

  56
  >
  		for i := range v.NumField() {
  
  57
  >
  			if p := hasSharedStructure(v.Field(i), path+"."+v.Type().Field(i).Name); p != "" {
  
  58
  
  				return p
  
  59
  
  			}

  66
  
  		}
  
  67
  
  	}
  
  68
  >
  	return ""
  
shared_structure.go

  69
  
  }

go.temporal.io/server/common/namespace/registry_mock.go 23 covered LOC · 5 ranges

Open complete file

  30
  
  31
  
  // NewMockRegistry creates a new mock instance.
  
  32
  >
  func NewMockRegistry(ctrl *gomock.Controller) *MockRegistry {
  
registry_mock.go

  33
  >
  	mock := &MockRegistry{ctrl: ctrl}
  
  34
  >
  	mock.recorder = &MockRegistryMockRecorder{mock}
  
  35
  >
  	return mock
  
  36
  >
  }
  
  37
  
  38
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  39
  >
  func (m *MockRegistry) EXPECT() *MockRegistryMockRecorder {
  
registry_mock.go

  40
  >
  	return m.recorder
  
  41
  >
  }
  
  42
  
  43
  
  // GetAllNamespaces mocks base method.

  80
  
  81
  
  // GetNamespace indicates an expected call of GetNamespace.
  
  82
  >
  func (mr *MockRegistryMockRecorder) GetNamespace(name any) *gomock.Call {
  
registry_mock.go

  83
  >
  	mr.mock.ctrl.T.Helper()
  
  84
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockRegistry)(nil).GetNamespace), name)
  
  85
  >
  }
  
  86
  
  87
  
  // GetNamespaceByID mocks base method.
  
  88
  >
  func (m *MockRegistry) GetNamespaceByID(id ID) (*Namespace, error) {
  
registry_mock.go

  89
  >
  	m.ctrl.T.Helper()
  
  90
  >
  	ret := m.ctrl.Call(m, "GetNamespaceByID", id)
  
  91
  >
  	ret0, _ := ret[0].(*Namespace)
  
  92
  >
  	ret1, _ := ret[1].(error)
  
  93
  >
  	return ret0, ret1
  
  94
  >
  }
  
  95
  
  96
  
  // GetNamespaceByID indicates an expected call of GetNamespaceByID.
  
  97
  >
  func (mr *MockRegistryMockRecorder) GetNamespaceByID(id any) *gomock.Call {
  
registry_mock.go

  98
  >
  	mr.mock.ctrl.T.Helper()
  
  99
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceByID", reflect.TypeOf((*MockRegistry)(nil).GetNamespaceByID), id)
  
  100
  >
  }
  
  101
  
  102
  
  // GetNamespaceByIDWithOptions mocks base method.

go.temporal.io/server/service/history/shard/task_key_generator.go 23 covered LOC · 4 ranges

Open complete file

  39
  
  	logger log.Logger,
  
  40
  
  	renewRangeIDFn renewRangeIDFn,
  
  41
  >
  ) *taskKeyGenerator {
  
task_key_generator.go

  42
  >
  	return &taskKeyGenerator{
  
  43
  >
  		nextTaskID:         taskIDUninitialized,
  
  44
  >
  		exclusiveMaxTaskID: taskIDUninitialized,
  
  45
  >
  		rangeSizeBits:      rangeSizeBits,
  
  46
  >
  		timeSource:         timeSource,
  
  47
  >
  		logger:             logger,
  
  48
  >
  		renewRangeIDFn:     renewRangeIDFn,
  
  49
  >
  	}
  
  50
  >
  }
  
  51
  
  52
  
  func (a *taskKeyGenerator) setTaskKeys(

  114
  
  func (a *taskKeyGenerator) peekTaskKey(
  
  115
  
  	category tasks.Category,
  
  116
  >
  ) tasks.Key {
  
task_key_generator.go

  117
  >
  	switch category.Type() {
  
  118
  >
  	case tasks.CategoryTypeImmediate:
  
task_key_generator.go

  119
  >
  		return tasks.NewImmediateKey(a.nextTaskID)
  
  120
  
  	case tasks.CategoryTypeScheduled:
  
  121
  
  		return tasks.NewKey(

  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(

go.temporal.io/server/api/common/v1/api_category.pb.go 22 covered LOC · 2 ranges

Open complete file

  204
  
  }
  
  205
  
  206
  >
  func init() { file_temporal_server_api_common_v1_api_category_proto_init() }
  
api_category.pb.go

  207
  >
  func file_temporal_server_api_common_v1_api_category_proto_init() {
  
  208
  >
  	if File_temporal_server_api_common_v1_api_category_proto != nil {
  
  209
  
  		return
  
  210
  
  	}
  
  211
  >
  	type x struct{}
  
api_category.pb.go

  212
  >
  	out := protoimpl.TypeBuilder{
  
  213
  >
  		File: protoimpl.DescBuilder{
  
  214
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  215
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_common_v1_api_category_proto_rawDesc), len(file_temporal_server_api_common_v1_api_category_proto_rawDesc)),
  
  216
  >
  			NumEnums:      1,
  
  217
  >
  			NumMessages:   1,
  
  218
  >
  			NumExtensions: 1,
  
  219
  >
  			NumServices:   0,
  
  220
  >
  		},
  
  221
  >
  		GoTypes:           file_temporal_server_api_common_v1_api_category_proto_goTypes,
  
  222
  >
  		DependencyIndexes: file_temporal_server_api_common_v1_api_category_proto_depIdxs,
  
  223
  >
  		EnumInfos:         file_temporal_server_api_common_v1_api_category_proto_enumTypes,
  
  224
  >
  		MessageInfos:      file_temporal_server_api_common_v1_api_category_proto_msgTypes,
  
  225
  >
  		ExtensionInfos:    file_temporal_server_api_common_v1_api_category_proto_extTypes,
  
  226
  >
  	}.Build()
  
  227
  >
  	File_temporal_server_api_common_v1_api_category_proto = out.File
  
  228
  >
  	file_temporal_server_api_common_v1_api_category_proto_goTypes = nil
  
  229
  >
  	file_temporal_server_api_common_v1_api_category_proto_depIdxs = nil
  
  230
  
  }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

  1057
  
  }
  
  1058
  
  1059
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() }
  
request_response.pb.go

  1060
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() {
  
  1061
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_request_response_proto != nil {
  
  1062
  >
  		return
  
  1063
  >
  	}
  
  1064
  >
  	type x struct{}
  
  1065
  >
  	out := protoimpl.TypeBuilder{
  
  1066
  >
  		File: protoimpl.DescBuilder{
  
  1067
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  1068
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDesc)),
  
  1069
  >
  			NumEnums:      0,
  
  1070
  >
  			NumMessages:   20,
  
  1071
  >
  			NumExtensions: 0,
  
  1072
  >
  			NumServices:   0,
  
  1073
  >
  		},
  
  1074
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_goTypes,
  
  1075
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_depIdxs,
  
  1076
  >
  		MessageInfos:      file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes,
  
  1077
  >
  	}.Build()
  
  1078
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_request_response_proto = out.File
  
  1079
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_goTypes = nil
  
  1080
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_depIdxs = nil
  
  1081
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

  672
  
  }
  
  673
  
  674
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init() }
  
request_response.pb.go

  675
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init() {
  
  676
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto != nil {
  
  677
  >
  		return
  
  678
  >
  	}
  
  679
  >
  	type x struct{}
  
  680
  >
  	out := protoimpl.TypeBuilder{
  
  681
  >
  		File: protoimpl.DescBuilder{
  
  682
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  683
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_rawDesc)),
  
  684
  >
  			NumEnums:      0,
  
  685
  >
  			NumMessages:   12,
  
  686
  >
  			NumExtensions: 0,
  
  687
  >
  			NumServices:   0,
  
  688
  >
  		},
  
  689
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_goTypes,
  
  690
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_depIdxs,
  
  691
  >
  		MessageInfos:      file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_msgTypes,
  
  692
  >
  	}.Build()
  
  693
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto = out.File
  
  694
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_goTypes = nil
  
  695
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_depIdxs = nil
  
  696
  
  }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/request_response.pb.go 22 covered LOC · 1 range

Open complete file

  157
  
  }
  
  158
  
  159
  >
  func init() { file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init() }
  
request_response.pb.go

  160
  >
  func file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init() {
  
  161
  >
  	if File_temporal_server_chasm_lib_tests_proto_v1_request_response_proto != nil {
  
  162
  >
  		return
  
  163
  >
  	}
  
  164
  >
  	type x struct{}
  
  165
  >
  	out := protoimpl.TypeBuilder{
  
  166
  >
  		File: protoimpl.DescBuilder{
  
  167
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  168
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_rawDesc)),
  
  169
  >
  			NumEnums:      0,
  
  170
  >
  			NumMessages:   2,
  
  171
  >
  			NumExtensions: 0,
  
  172
  >
  			NumServices:   0,
  
  173
  >
  		},
  
  174
  >
  		GoTypes:           file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_goTypes,
  
  175
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_depIdxs,
  
  176
  >
  		MessageInfos:      file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_msgTypes,
  
  177
  >
  	}.Build()
  
  178
  >
  	File_temporal_server_chasm_lib_tests_proto_v1_request_response_proto = out.File
  
  179
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_goTypes = nil
  
  180
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_depIdxs = nil
  
  181
  
  }

go.temporal.io/server/common/future/future_impl.go 22 covered LOC · 3 ranges

Open complete file

  29
  
  )
  
  30
  
  31
  >
  func NewFuture[T any]() *FutureImpl[T] {
  
future_impl.go

  32
  >
  	var value T
  
  33
  >
  	return &FutureImpl[T]{
  
  34
  >
  		status:  pending,
  
  35
  >
  		readyCh: make(chan struct{}),
  
  36
  >
  
  37
  >
  		value: value,
  
  38
  >
  		err:   nil,
  
  39
  >
  	}
  
  40
  >
  }
  
  41
  
  42
  
  func (f *FutureImpl[T]) Get(

  67
  
  	value T,
  
  68
  
  	err error,
  
  69
  >
  ) {
  
future_impl.go

  70
  >
  	// cannot directly set status to `ready`, to prevent data race in case multiple `Get` occurs
  
  71
  >
  	// instead set status to `setting` to prevent concurrent completion of this future
  
  72
  >
  	if !atomic.CompareAndSwapInt32(
  
  73
  >
  		&f.status,
  
  74
  >
  		pending,
  
  75
  >
  		setting,
  
  76
  >
  	) {
  
  77
  
  		panic("future has already been completed")
  
  78
  
  	}
  
  79
  
  80
  >
  	f.value = value
  
future_impl.go

  81
  >
  	f.err = err
  
  82
  >
  	atomic.CompareAndSwapInt32(&f.status, setting, ready)
  
  83
  >
  	close(f.readyCh)
  
  84
  
  }
  
  85

go.temporal.io/server/api/persistence/v1/task_queues.pb.go 21 covered LOC · 2 ranges

Open complete file

  899
  
  }
  
  900
  
  901
  >
  func init() { file_temporal_server_api_persistence_v1_task_queues_proto_init() }
  
task_queues.pb.go

  902
  >
  func file_temporal_server_api_persistence_v1_task_queues_proto_init() {
  
  903
  >
  	if File_temporal_server_api_persistence_v1_task_queues_proto != nil {
  
  904
  
  		return
  
  905
  
  	}
  
  906
  >
  	type x struct{}
  
task_queues.pb.go

  907
  >
  	out := protoimpl.TypeBuilder{
  
  908
  >
  		File: protoimpl.DescBuilder{
  
  909
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  910
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_task_queues_proto_rawDesc), len(file_temporal_server_api_persistence_v1_task_queues_proto_rawDesc)),
  
  911
  >
  			NumEnums:      1,
  
  912
  >
  			NumMessages:   13,
  
  913
  >
  			NumExtensions: 0,
  
  914
  >
  			NumServices:   0,
  
  915
  >
  		},
  
  916
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_task_queues_proto_goTypes,
  
  917
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_task_queues_proto_depIdxs,
  
  918
  >
  		EnumInfos:         file_temporal_server_api_persistence_v1_task_queues_proto_enumTypes,
  
  919
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_task_queues_proto_msgTypes,
  
  920
  >
  	}.Build()
  
  921
  >
  	File_temporal_server_api_persistence_v1_task_queues_proto = out.File
  
  922
  >
  	file_temporal_server_api_persistence_v1_task_queues_proto_goTypes = nil
  
  923
  >
  	file_temporal_server_api_persistence_v1_task_queues_proto_depIdxs = nil
  
  924
  
  }

go.temporal.io/server/api/routing/v1/extension.pb.go 21 covered LOC · 2 ranges

Open complete file

  144
  
  }
  
  145
  
  146
  >
  func init() { file_temporal_server_api_routing_v1_extension_proto_init() }
  
extension.pb.go

  147
  >
  func file_temporal_server_api_routing_v1_extension_proto_init() {
  
  148
  >
  	if File_temporal_server_api_routing_v1_extension_proto != nil {
  
  149
  
  		return
  
  150
  
  	}
  
  151
  >
  	type x struct{}
  
extension.pb.go

  152
  >
  	out := protoimpl.TypeBuilder{
  
  153
  >
  		File: protoimpl.DescBuilder{
  
  154
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  155
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_routing_v1_extension_proto_rawDesc), len(file_temporal_server_api_routing_v1_extension_proto_rawDesc)),
  
  156
  >
  			NumEnums:      0,
  
  157
  >
  			NumMessages:   1,
  
  158
  >
  			NumExtensions: 1,
  
  159
  >
  			NumServices:   0,
  
  160
  >
  		},
  
  161
  >
  		GoTypes:           file_temporal_server_api_routing_v1_extension_proto_goTypes,
  
  162
  >
  		DependencyIndexes: file_temporal_server_api_routing_v1_extension_proto_depIdxs,
  
  163
  >
  		MessageInfos:      file_temporal_server_api_routing_v1_extension_proto_msgTypes,
  
  164
  >
  		ExtensionInfos:    file_temporal_server_api_routing_v1_extension_proto_extTypes,
  
  165
  >
  	}.Build()
  
  166
  >
  	File_temporal_server_api_routing_v1_extension_proto = out.File
  
  167
  >
  	file_temporal_server_api_routing_v1_extension_proto_goTypes = nil
  
  168
  >
  	file_temporal_server_api_routing_v1_extension_proto_depIdxs = nil
  
  169
  
  }

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/tasks.pb.go 21 covered LOC · 2 ranges

Open complete file

  495
  
  }
  
  496
  
  497
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  498
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_init() {
  
  499
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_tasks_proto != nil {
  
  500
  
  		return
  
  501
  
  	}
  
  502
  >
  	type x struct{}
  
tasks.pb.go

  503
  >
  	out := protoimpl.TypeBuilder{
  
  504
  >
  		File: protoimpl.DescBuilder{
  
  505
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  506
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_rawDesc)),
  
  507
  >
  			NumEnums:      2,
  
  508
  >
  			NumMessages:   5,
  
  509
  >
  			NumExtensions: 0,
  
  510
  >
  			NumServices:   0,
  
  511
  >
  		},
  
  512
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_goTypes,
  
  513
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_depIdxs,
  
  514
  >
  		EnumInfos:         file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_enumTypes,
  
  515
  >
  		MessageInfos:      file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_msgTypes,
  
  516
  >
  	}.Build()
  
  517
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_tasks_proto = out.File
  
  518
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_goTypes = nil
  
  519
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_tasks_proto_depIdxs = nil
  
  520
  
  }

go.temporal.io/server/common/log/tag/zap_tag.go 21 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 {
  
zap_tag.go

  33
  >
  	return t.field.Key
  
  34
  >
  }
  
  35
  
  36
  
  func (t ZapTag) Value() any {

  44
  
  }
  
  45
  
  46
  >
  func NewStringTag(key string, value string) ZapTag {
  
zap_tag.go

  47
  >
  	return ZapTag{
  
  48
  >
  		field: zap.String(key, value),
  
  49
  >
  	}
  
  50
  >
  }
  
  51
  
  52
  
  func NewStringsTag(key string, value []string) ZapTag {

  82
  
  }
  
  83
  
  84
  >
  func NewInt64(key string, value int64) ZapTag {
  
zap_tag.go

  85
  >
  	return ZapTag{
  
  86
  >
  		field: zap.Int64(key, value),
  
  87
  >
  	}
  
  88
  >
  }
  
  89
  
  90
  
  func NewInt(key string, value int) ZapTag {

  118
  
  }
  
  119
  
  120
  >
  func NewBoolTag(key string, value bool) ZapTag {
  
zap_tag.go

  121
  >
  	return ZapTag{
  
  122
  >
  		field: zap.Bool(key, value),
  
  123
  >
  	}
  
  124
  >
  }
  
  125
  
  126
  
  func NewErrorTag(key string, value error) ZapTag {

go.temporal.io/server/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/context.go 20 covered LOC · 3 ranges

Open complete file

  133
  
  	ctx context.Context,
  
  134
  
  	node *Node,
  
  135
  >
  ) Context {
  
context.go

  136
  >
  	return newContext(ctx, node)
  
  137
  >
  }
  
  138
  
  139
  
  // newContext creates a new immutableCtx from an existing Context and root Node.

  142
  
  	ctx context.Context,
  
  143
  
  	node *Node,
  
  144
  >
  ) *immutableCtx {
  
context.go

  145
  >
  	root := node.root()
  
  146
  >
  	workflowKey := node.backend.GetWorkflowKey()
  
  147
  >
  	return &immutableCtx{
  
  148
  >
  		ctx:  ctx,
  
  149
  >
  		now:  root.Now(nil),
  
  150
  >
  		root: root,
  
  151
  >
  		executionKey: ExecutionKey{
  
  152
  >
  			NamespaceID: workflowKey.NamespaceID,
  
  153
  >
  			BusinessID:  workflowKey.WorkflowID,
  
  154
  >
  			RunID:       workflowKey.RunID,
  
  155
  >
  		},
  
  156
  >
  	}
  
  157
  >
  }
  
  158
  
  159
  
  func (c *immutableCtx) Ref(component Component) ([]byte, error) {

  230
  
  }
  
  231
  
  232
  >
  func (c *immutableCtx) goContext() context.Context {
  
context.go

  233
  >
  	return c.ctx
  
  234
  >
  }
  
  235
  
  236
  
  func (c *immutableCtx) RequestHeader(key string) string {

go.temporal.io/server/chasm/lib/activity/gen/activitypb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  91
  
  }
  
  92
  
  93
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() }
  
service.pb.go

  94
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() {
  
  95
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_service_proto != nil {
  
  96
  
  		return
  
  97
  
  	}
  
  98
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init()
  
service.pb.go

  99
  >
  	type x struct{}
  
  100
  >
  	out := protoimpl.TypeBuilder{
  
  101
  >
  		File: protoimpl.DescBuilder{
  
  102
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  103
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc)),
  
  104
  >
  			NumEnums:      0,
  
  105
  >
  			NumMessages:   0,
  
  106
  >
  			NumExtensions: 0,
  
  107
  >
  			NumServices:   1,
  
  108
  >
  		},
  
  109
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes,
  
  110
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs,
  
  111
  >
  	}.Build()
  
  112
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_service_proto = out.File
  
  113
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes = nil
  
  114
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs = nil
  
  115
  
  }

go.temporal.io/server/chasm/lib/callback/gen/callbackpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

  148
  
  }
  
  149
  
  150
  >
  func init() { file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  151
  >
  func file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() {
  
  152
  >
  	if File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto != nil {
  
  153
  
  		return
  
  154
  
  	}
  
  155
  >
  	type x struct{}
  
tasks.pb.go

  156
  >
  	out := protoimpl.TypeBuilder{
  
  157
  >
  		File: protoimpl.DescBuilder{
  
  158
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  159
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc)),
  
  160
  >
  			NumEnums:      0,
  
  161
  >
  			NumMessages:   2,
  
  162
  >
  			NumExtensions: 0,
  
  163
  >
  			NumServices:   0,
  
  164
  >
  		},
  
  165
  >
  		GoTypes:           file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes,
  
  166
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs,
  
  167
  >
  		MessageInfos:      file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_msgTypes,
  
  168
  >
  	}.Build()
  
  169
  >
  	File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto = out.File
  
  170
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes = nil
  
  171
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs = nil
  
  172
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  71
  
  }
  
  72
  
  73
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() }
  
service.pb.go

  74
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() {
  
  75
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto != nil {
  
  76
  
  		return
  
  77
  
  	}
  
  78
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init()
  
service.pb.go

  79
  >
  	type x struct{}
  
  80
  >
  	out := protoimpl.TypeBuilder{
  
  81
  >
  		File: protoimpl.DescBuilder{
  
  82
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  83
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc)),
  
  84
  >
  			NumEnums:      0,
  
  85
  >
  			NumMessages:   0,
  
  86
  >
  			NumExtensions: 0,
  
  87
  >
  			NumServices:   1,
  
  88
  >
  		},
  
  89
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes,
  
  90
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs,
  
  91
  >
  	}.Build()
  
  92
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto = out.File
  
  93
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes = nil
  
  94
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs = nil
  
  95
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/gen/nexusoperationpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

  354
  
  }
  
  355
  
  356
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  357
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() {
  
  358
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto != nil {
  
  359
  
  		return
  
  360
  
  	}
  
  361
  >
  	type x struct{}
  
tasks.pb.go

  362
  >
  	out := protoimpl.TypeBuilder{
  
  363
  >
  		File: protoimpl.DescBuilder{
  
  364
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  365
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc)),
  
  366
  >
  			NumEnums:      0,
  
  367
  >
  			NumMessages:   7,
  
  368
  >
  			NumExtensions: 0,
  
  369
  >
  			NumServices:   0,
  
  370
  >
  		},
  
  371
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes,
  
  372
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs,
  
  373
  >
  		MessageInfos:      file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_msgTypes,
  
  374
  >
  	}.Build()
  
  375
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto = out.File
  
  376
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes = nil
  
  377
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs = nil
  
  378
  
  }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  86
  
  }
  
  87
  
  88
  >
  func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_init() }
  
service.pb.go

  89
  >
  func file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_init() {
  
  90
  >
  	if File_temporal_server_chasm_lib_scheduler_proto_v1_service_proto != nil {
  
  91
  
  		return
  
  92
  
  	}
  
  93
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_request_response_proto_init()
  
service.pb.go

  94
  >
  	type x struct{}
  
  95
  >
  	out := protoimpl.TypeBuilder{
  
  96
  >
  		File: protoimpl.DescBuilder{
  
  97
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  98
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_rawDesc)),
  
  99
  >
  			NumEnums:      0,
  
  100
  >
  			NumMessages:   0,
  
  101
  >
  			NumExtensions: 0,
  
  102
  >
  			NumServices:   1,
  
  103
  >
  		},
  
  104
  >
  		GoTypes:           file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_goTypes,
  
  105
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_depIdxs,
  
  106
  >
  	}.Build()
  
  107
  >
  	File_temporal_server_chasm_lib_scheduler_proto_v1_service_proto = out.File
  
  108
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_goTypes = nil
  
  109
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_service_proto_depIdxs = nil
  
  110
  
  }

go.temporal.io/server/chasm/lib/scheduler/gen/schedulerpb/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

  343
  
  }
  
  344
  
  345
  >
  func init() { file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  346
  >
  func file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_init() {
  
  347
  >
  	if File_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto != nil {
  
  348
  
  		return
  
  349
  
  	}
  
  350
  >
  	type x struct{}
  
tasks.pb.go

  351
  >
  	out := protoimpl.TypeBuilder{
  
  352
  >
  		File: protoimpl.DescBuilder{
  
  353
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  354
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_rawDesc)),
  
  355
  >
  			NumEnums:      0,
  
  356
  >
  			NumMessages:   7,
  
  357
  >
  			NumExtensions: 0,
  
  358
  >
  			NumServices:   0,
  
  359
  >
  		},
  
  360
  >
  		GoTypes:           file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_goTypes,
  
  361
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_depIdxs,
  
  362
  >
  		MessageInfos:      file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_msgTypes,
  
  363
  >
  	}.Build()
  
  364
  >
  	File_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto = out.File
  
  365
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_goTypes = nil
  
  366
  >
  	file_temporal_server_chasm_lib_scheduler_proto_v1_tasks_proto_depIdxs = nil
  
  367
  
  }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  242
  
  }
  
  243
  
  244
  >
  func init() { file_temporal_server_chasm_lib_tests_proto_v1_message_proto_init() }
  
message.pb.go

  245
  >
  func file_temporal_server_chasm_lib_tests_proto_v1_message_proto_init() {
  
  246
  >
  	if File_temporal_server_chasm_lib_tests_proto_v1_message_proto != nil {
  
  247
  
  		return
  
  248
  
  	}
  
  249
  >
  	type x struct{}
  
message.pb.go

  250
  >
  	out := protoimpl.TypeBuilder{
  
  251
  >
  		File: protoimpl.DescBuilder{
  
  252
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  253
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_message_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_message_proto_rawDesc)),
  
  254
  >
  			NumEnums:      0,
  
  255
  >
  			NumMessages:   4,
  
  256
  >
  			NumExtensions: 0,
  
  257
  >
  			NumServices:   0,
  
  258
  >
  		},
  
  259
  >
  		GoTypes:           file_temporal_server_chasm_lib_tests_proto_v1_message_proto_goTypes,
  
  260
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_message_proto_depIdxs,
  
  261
  >
  		MessageInfos:      file_temporal_server_chasm_lib_tests_proto_v1_message_proto_msgTypes,
  
  262
  >
  	}.Build()
  
  263
  >
  	File_temporal_server_chasm_lib_tests_proto_v1_message_proto = out.File
  
  264
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_message_proto_goTypes = nil
  
  265
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_message_proto_depIdxs = nil
  
  266
  
  }

go.temporal.io/server/chasm/lib/tests/gen/testspb/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  46
  
  }
  
  47
  
  48
  >
  func init() { file_temporal_server_chasm_lib_tests_proto_v1_service_proto_init() }
  
service.pb.go

  49
  >
  func file_temporal_server_chasm_lib_tests_proto_v1_service_proto_init() {
  
  50
  >
  	if File_temporal_server_chasm_lib_tests_proto_v1_service_proto != nil {
  
  51
  
  		return
  
  52
  
  	}
  
  53
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_request_response_proto_init()
  
service.pb.go

  54
  >
  	type x struct{}
  
  55
  >
  	out := protoimpl.TypeBuilder{
  
  56
  >
  		File: protoimpl.DescBuilder{
  
  57
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  58
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_tests_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_tests_proto_v1_service_proto_rawDesc)),
  
  59
  >
  			NumEnums:      0,
  
  60
  >
  			NumMessages:   0,
  
  61
  >
  			NumExtensions: 0,
  
  62
  >
  			NumServices:   1,
  
  63
  >
  		},
  
  64
  >
  		GoTypes:           file_temporal_server_chasm_lib_tests_proto_v1_service_proto_goTypes,
  
  65
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_tests_proto_v1_service_proto_depIdxs,
  
  66
  >
  	}.Build()
  
  67
  >
  	File_temporal_server_chasm_lib_tests_proto_v1_service_proto = out.File
  
  68
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_service_proto_goTypes = nil
  
  69
  >
  	file_temporal_server_chasm_lib_tests_proto_v1_service_proto_depIdxs = nil
  
  70
  
  }

go.temporal.io/server/chasm/lib/workflow/gen/workflowpb/v1/state.pb.go 20 covered LOC · 2 ranges

Open complete file

  211
  
  }
  
  212
  
  213
  >
  func init() { file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_init() }
  
state.pb.go

  214
  >
  func file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_init() {
  
  215
  >
  	if File_temporal_server_chasm_lib_workflow_proto_v1_state_proto != nil {
  
  216
  
  		return
  
  217
  
  	}
  
  218
  >
  	type x struct{}
  
state.pb.go

  219
  >
  	out := protoimpl.TypeBuilder{
  
  220
  >
  		File: protoimpl.DescBuilder{
  
  221
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  222
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_rawDesc), len(file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_rawDesc)),
  
  223
  >
  			NumEnums:      0,
  
  224
  >
  			NumMessages:   3,
  
  225
  >
  			NumExtensions: 0,
  
  226
  >
  			NumServices:   0,
  
  227
  >
  		},
  
  228
  >
  		GoTypes:           file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_goTypes,
  
  229
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_depIdxs,
  
  230
  >
  		MessageInfos:      file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_msgTypes,
  
  231
  >
  	}.Build()
  
  232
  >
  	File_temporal_server_chasm_lib_workflow_proto_v1_state_proto = out.File
  
  233
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_goTypes = nil
  
  234
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_depIdxs = nil
  
  235
  
  }

go.temporal.io/server/chasm/lib/workflow/gen/workflowpb/v1/update_state.pb.go 20 covered LOC · 2 ranges

Open complete file

  113
  
  }
  
  114
  
  115
  >
  func init() { file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_init() }
  
update_state.pb.go

  116
  >
  func file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_init() {
  
  117
  >
  	if File_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto != nil {
  
  118
  
  		return
  
  119
  
  	}
  
  120
  >
  	type x struct{}
  
update_state.pb.go

  121
  >
  	out := protoimpl.TypeBuilder{
  
  122
  >
  		File: protoimpl.DescBuilder{
  
  123
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  124
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_rawDesc), len(file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_rawDesc)),
  
  125
  >
  			NumEnums:      0,
  
  126
  >
  			NumMessages:   1,
  
  127
  >
  			NumExtensions: 0,
  
  128
  >
  			NumServices:   0,
  
  129
  >
  		},
  
  130
  >
  		GoTypes:           file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_goTypes,
  
  131
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_depIdxs,
  
  132
  >
  		MessageInfos:      file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_msgTypes,
  
  133
  >
  	}.Build()
  
  134
  >
  	File_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto = out.File
  
  135
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_goTypes = nil
  
  136
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_depIdxs = nil
  
  137
  
  }

go.temporal.io/server/common/primitives/uuid.go 20 covered LOC · 5 ranges

Open complete file

  68
  
  69
  
  // NewUUID generates a new random UUID
  
  70
  >
  func NewUUID() UUID {
  
uuid.go

  71
  >
  	u, err := guuid.NewV7()
  
  72
  >
  	if err != nil {
  
  73
  
  		// Should never happen, but this matches the behavior of google/uuid.NewRandom
  
  74
  
  		return nil
  
  75
  
  	}
  
  76
  >
  	return u[:]
  
uuid.go

  77
  
  }
  
  78

  91
  
  // String returns the 36 byte hexstring representation of this uuid
  
  92
  
  // return empty string if this uuid is nil
  
  93
  >
  func (u UUID) String() string {
  
uuid.go

  94
  >
  	if len(u) != 16 {
  
  95
  
  		return ""
  
  96
  
  	}
  
  97
  >
  	var buf [36]byte
  
uuid.go

  98
  >
  	u.encodeHex(buf[:])
  
  99
  >
  	return string(buf[:])
  
  100
  
  }
  
  101

  140
  
  }
  
  141
  
  142
  >
  func (u UUID) encodeHex(dst []byte) {
  
uuid.go

  143
  >
  	hex.Encode(dst, u[:4])
  
  144
  >
  	dst[8] = '-'
  
  145
  >
  	hex.Encode(dst[9:13], u[4:6])
  
  146
  >
  	dst[13] = '-'
  
  147
  >
  	hex.Encode(dst[14:18], u[6:8])
  
  148
  >
  	dst[18] = '-'
  
  149
  >
  	hex.Encode(dst[19:23], u[8:10])
  
  150
  >
  	dst[23] = '-'
  
  151
  >
  	hex.Encode(dst[24:], u[10:])
  
  152
  >
  }

go.temporal.io/server/common/util/wildcard.go 20 covered LOC · 7 ranges

Open complete file

  18
  
  // WildCardStringToRegexps converts a given slices of string patterns to a slice of regular expressions matching
  
  19
  
  // wildcards (*) with any substring.
  
  20
  >
  func WildCardStringsToRegexp(patterns []string) (*regexp.Regexp, error) {
  
wildcard.go

  21
  >
  	var result strings.Builder
  
  22
  >
  	result.WriteRune('^')
  
  23
  >
  	for i, pattern := range patterns {
  
  24
  >
  		result.WriteRune('(')
  
  25
  >
  		first := true
  
  26
  >
  		for literal := range strings.SplitSeq(pattern, "*") {
  
  27
  >
  			if !first {
  
  28
  
  				// Replace * with .*
  
  29
  
  				result.WriteString(".*")
  
  30
  
  			}
  
  31
  >
  			result.WriteString(regexp.QuoteMeta(literal))
  
wildcard.go

  32
  >
  			first = false
  
  33
  
  		}
  
  34
  >
  		result.WriteRune(')')
  
wildcard.go

  35
  >
  		if i < len(patterns)-1 {
  
  36
  >
  			result.WriteRune('|')
  
wildcard.go

  37
  >
  		}
  
  38
  
  	}
  
  39
  >
  	result.WriteRune('$')
  
wildcard.go

  40
  >
  	return regexp.Compile(result.String())
  
  41
  
  }
  
  42
  
  43
  
  // MustWildCardStringsToRegexp is like WildCardStringsToRegexp but panics on error.
  
  44
  >
  func MustWildCardStringsToRegexp(patterns []string) *regexp.Regexp {
  
wildcard.go

  45
  >
  	re, err := WildCardStringsToRegexp(patterns)
  
  46
  >
  	if err != nil {
  
  47
  
  		panic(err) //nolint:forbidigo // Must* functions conventionally panic on error.
  
  48
  
  	}
  
  49
  >
  	return re
  
wildcard.go

  50
  
  }

go.temporal.io/server/service/history/shard/task_request_tracker.go 20 covered LOC · 4 ranges

Open complete file

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

  27
  >
  	outstandingTaskKeys := make(map[tasks.Category]map[tasks.Key]struct{})
  
  28
  >
  	for _, category := range registry.GetCategories() {
  
  29
  >
  		outstandingTaskKeys[category] = make(map[tasks.Key]struct{})
  
  30
  >
  	}
  
  31
  >
  	return &taskRequestTracker{
  
  32
  >
  		pendingTaskKeys: outstandingTaskKeys,
  
  33
  >
  	}
  
  34
  
  }
  
  35

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

  133
  >
  	t.Lock()
  
  134
  >
  	defer t.Unlock()
  
  135
  >
  
  136
  >
  	for category := range t.pendingTaskKeys {
  
  137
  >
  		t.pendingTaskKeys[category] = make(map[tasks.Key]struct{})
  
  138
  >
  	}
  
  139
  >
  	t.inflightRequestCount = 0
  
  140
  >
  	t.closeWaitChannelsLocked()
  
  141
  
  }
  
  142
  
  143
  >
  func (t *taskRequestTracker) closeWaitChannelsLocked() {
  
task_request_tracker.go

  144
  >
  	for _, waitCh := range t.waitChannels {
  
  145
  
  		close(waitCh)
  
  146
  
  	}
  
  147
  >
  	t.waitChannels = nil
  
task_request_tracker.go

  148
  
  }

go.temporal.io/server/service/history/hsm/registry.go 19 covered LOC · 4 ranges

Open complete file

  47
  
  48
  
  // NewRegistry creates a new [Registry].
  
  49
  >
  func NewRegistry() *Registry {
  
registry.go

  50
  >
  	return &Registry{
  
  51
  >
  		machines:           make(map[string]StateMachineDefinition),
  
  52
  >
  		tasks:              make(map[string]TaskSerializer),
  
  53
  >
  		immediateExecutors: make(map[string]any),
  
  54
  >
  		timerExecutors:     make(map[string]any),
  
  55
  >
  		remoteExecutors:    make(map[string]remoteMethodDefinition),
  
  56
  >
  		events:             make(map[enumspb.EventType]EventDefinition),
  
  57
  >
  	}
  
  58
  >
  }
  
  59
  
  60
  
  // RegisterMachine registers a [StateMachineDefinition] by its type.
  
  61
  
  // Returns an [ErrDuplicateRegistration] if the state machine type has already been registered.
  
  62
  >
  func (r *Registry) RegisterMachine(sm StateMachineDefinition) error {
  
registry.go

  63
  >
  	t := sm.Type()
  
  64
  >
  	if existing, ok := r.machines[t]; ok {
  
  65
  
  		return fmt.Errorf("%w: state machine already registered for %v - %v", ErrDuplicateRegistration, sm.Type(), existing.Type())
  
  66
  
  	}
  
  67
  >
  	r.machines[t] = sm
  
registry.go

  68
  >
  	return nil
  
  69
  
  }
  
  70
  
  71
  
  // Machine returns a [StateMachineDefinition] for a given type and a boolean indicating whether it was found.
  
  72
  >
  func (r *Registry) Machine(t string) (def StateMachineDefinition, ok bool) {
  
registry.go

  73
  >
  	def, ok = r.machines[t]
  
  74
  >
  	return
  
  75
  >
  }
  
  76
  
  77
  
  // RegisterTaskSerializer registers a [TaskSerializer] for a given type.

go.temporal.io/server/service/history/shard/controller_mock.go 19 covered LOC · 4 ranges

Open complete file

  33
  
  34
  
  // NewMockController creates a new mock instance.
  
  35
  >
  func NewMockController(ctrl *gomock.Controller) *MockController {
  
controller_mock.go

  36
  >
  	mock := &MockController{ctrl: ctrl}
  
  37
  >
  	mock.recorder = &MockControllerMockRecorder{mock}
  
  38
  >
  	return mock
  
  39
  >
  }
  
  40
  
  41
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  42
  >
  func (m *MockController) EXPECT() *MockControllerMockRecorder {
  
controller_mock.go

  43
  >
  	return m.recorder
  
  44
  >
  }
  
  45
  
  46
  
  // CloseShardByID mocks base method.

  71
  
  72
  
  // GetShardByID mocks base method.
  
  73
  >
  func (m *MockController) GetShardByID(shardID int32) (interfaces.ShardContext, error) {
  
controller_mock.go

  74
  >
  	m.ctrl.T.Helper()
  
  75
  >
  	ret := m.ctrl.Call(m, "GetShardByID", shardID)
  
  76
  >
  	ret0, _ := ret[0].(interfaces.ShardContext)
  
  77
  >
  	ret1, _ := ret[1].(error)
  
  78
  >
  	return ret0, ret1
  
  79
  >
  }
  
  80
  
  81
  
  // GetShardByID indicates an expected call of GetShardByID.
  
  82
  >
  func (mr *MockControllerMockRecorder) GetShardByID(shardID any) *gomock.Call {
  
controller_mock.go

  83
  >
  	mr.mock.ctrl.T.Helper()
  
  84
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShardByID", reflect.TypeOf((*MockController)(nil).GetShardByID), shardID)
  
  85
  >
  }
  
  86
  
  87
  
  // GetShardByNamespaceWorkflow mocks base method.

go.temporal.io/server/service/history/workflow/task_generator_provider.go 19 covered LOC · 4 ranges

Open complete file

  23
  
  )
  
  24
  
  25
  >
  func init() {
  
task_generator_provider.go

  26
  >
  	var defaultProvider TaskGeneratorProvider = new(taskGeneratorProviderImpl)
  
  27
  >
  	populateTaskGeneratorProvider(defaultProvider)
  
  28
  >
  }
  
  29
  
  30
  >
  func populateTaskGeneratorProvider(provider TaskGeneratorProvider) {
  
task_generator_provider.go

  31
  >
  	_taskGeneratorProvider.Store(&provider)
  
  32
  >
  }
  
  33
  
  34
  >
  func GetTaskGeneratorProvider() TaskGeneratorProvider {
  
task_generator_provider.go

  35
  >
  	return *_taskGeneratorProvider.Load()
  
  36
  >
  }
  
  37
  
  38
  
  func (p *taskGeneratorProviderImpl) NewTaskGenerator(
  
  39
  
  	shard historyi.ShardContext,
  
  40
  
  	mutableState historyi.MutableState,
  
  41
  >
  ) TaskGenerator {
  
task_generator_provider.go

  42
  >
  	return NewTaskGenerator(
  
  43
  >
  		shard.GetNamespaceRegistry(),
  
  44
  >
  		mutableState,
  
  45
  >
  		shard.GetConfig(),
  
  46
  >
  		shard.GetArchivalMetadata(),
  
  47
  >
  		shard.GetLogger(),
  
  48
  >
  	)
  
  49
  >
  }

go.temporal.io/server/common/metrics/tags.go 18 covered LOC · 9 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

  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 {

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/tasks/task_category_registry.go 18 covered LOC · 4 ranges

Open complete file

  26
  
  // each entry point that uses it. Essentially, get it from the dependency graph instead of calling this method, unless
  
  27
  
  // you're in a test.
  
  28
  >
  func NewDefaultTaskCategoryRegistry() *MutableTaskCategoryRegistry {
  
task_category_registry.go

  29
  >
  	return &MutableTaskCategoryRegistry{
  
  30
  >
  		categories: map[int]Category{
  
  31
  >
  			CategoryTransfer.ID():    CategoryTransfer,
  
  32
  >
  			CategoryTimer.ID():       CategoryTimer,
  
  33
  >
  			CategoryVisibility.ID():  CategoryVisibility,
  
  34
  >
  			CategoryReplication.ID(): CategoryReplication,
  
  35
  >
  			CategoryMemoryTimer.ID(): CategoryMemoryTimer,
  
  36
  >
  			CategoryOutbound.ID():    CategoryOutbound,
  
  37
  >
  		},
  
  38
  >
  	}
  
  39
  >
  }
  
  40
  
  41
  
  // AddCategory register a Category with the registry or panics if a Category with the same ID has already been
  
  42
  
  // registered.
  
  43
  >
  func (r *MutableTaskCategoryRegistry) AddCategory(c Category) {
  
task_category_registry.go

  44
  >
  	if category, ok := r.categories[c.id]; ok {
  
  45
  
  		panic(fmt.Sprintf(
  
  46
  
  			"category id: %v has already been defined as type %v and name %v",

  51
  
  	}
  
  52
  
  53
  >
  	r.categories[c.id] = c
  
task_category_registry.go

  54
  
  }
  
  55

  61
  
  62
  
  // GetCategories returns a deep copy of all registered Category objects from the registry.
  
  63
  >
  func (r *MutableTaskCategoryRegistry) GetCategories() map[int]Category {
  
task_category_registry.go

  64
  >
  	return maps.Clone(r.categories)
  
  65
  >
  }

go.temporal.io/server/service/history/interfaces/engine_mock.go 16 covered LOC · 4 ranges

Open complete file

  45
  
  46
  
  // NewMockEngine creates a new mock instance.
  
  47
  >
  func NewMockEngine(ctrl *gomock.Controller) *MockEngine {
  
engine_mock.go

  48
  >
  	mock := &MockEngine{ctrl: ctrl}
  
  49
  >
  	mock.recorder = &MockEngineMockRecorder{mock}
  
  50
  >
  	return mock
  
  51
  >
  }
  
  52
  
  53
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  54
  >
  func (m *MockEngine) EXPECT() *MockEngineMockRecorder {
  
engine_mock.go

  55
  >
  	return m.recorder
  
  56
  >
  }
  
  57
  
  58
  
  // AddTasks mocks base method.

  434
  
  435
  
  // NotifyNewHistoryEvent indicates an expected call of NotifyNewHistoryEvent.
  
  436
  >
  func (mr *MockEngineMockRecorder) NotifyNewHistoryEvent(event any) *gomock.Call {
  
engine_mock.go

  437
  >
  	mr.mock.ctrl.T.Helper()
  
  438
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyNewHistoryEvent", reflect.TypeOf((*MockEngine)(nil).NotifyNewHistoryEvent), event)
  
  439
  >
  }
  
  440
  
  441
  
  // NotifyNewTasks mocks base method.

  446
  
  447
  
  // NotifyNewTasks indicates an expected call of NotifyNewTasks.
  
  448
  >
  func (mr *MockEngineMockRecorder) NotifyNewTasks(arg0 any) *gomock.Call {
  
engine_mock.go

  449
  >
  	mr.mock.ctrl.T.Helper()
  
  450
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyNewTasks", reflect.TypeOf((*MockEngine)(nil).NotifyNewTasks), arg0)
  
  451
  >
  }
  
  452
  
  453
  
  // PauseActivity mocks base method.

go.temporal.io/server/common/persistence/visibility/store/sql/query_converter_util_legacy.go 15 covered LOC · 3 ranges

Open complete file

  68
  
  }
  
  69
  
  70
  >
  func newColName(name string) *colName {
  
query_converter_util_legacy.go

  71
  >
  	return &colName{Name: name}
  
  72
  >
  }
  
  73
  
  74
  
  func newSAColName(

  77
  
  	fieldName string,
  
  78
  
  	valueType enumspb.IndexedValueType,
  
  79
  >
  ) *saColName {
  
query_converter_util_legacy.go

  80
  >
  	return &saColName{
  
  81
  >
  		dbColName: newColName(dbColName),
  
  82
  >
  		alias:     alias,
  
  83
  >
  		fieldName: fieldName,
  
  84
  >
  		valueType: valueType,
  
  85
  >
  	}
  
  86
  >
  }
  
  87
  
  88
  
  func newFuncExpr(name string, exprs ...sqlparser.Expr) *sqlparser.FuncExpr {

  105
  
  }
  
  106
  
  107
  >
  func getMaxDatetimeValue() time.Time {
  
query_converter_util_legacy.go

  108
  >
  	t, _ := time.Parse(time.RFC3339, "9999-12-31T23:59:59Z")
  
  109
  >
  	return t
  
  110
  >
  }
  
  111
  
  112
  
  // formatComparisonExprStringForError formats comparison expression after

go.temporal.io/server/common/build/build.go 14 covered LOC · 2 ranges

Open complete file

  27
  
  )
  
  28
  
  29
  >
  func init() {
  
build.go

  30
  >
  	buildInfo, ok := debug.ReadBuildInfo()
  
  31
  >
  	if !ok {
  
  32
  
  		return
  
  33
  
  	}
  
  34
  
  35
  >
  	InfoData.Available = true
  
build.go

  36
  >
  	InfoData.GoVersion = buildInfo.GoVersion
  
  37
  >
  
  38
  >
  	for _, setting := range buildInfo.Settings {
  
  39
  >
  		switch setting.Key {
  
  40
  >
  		case "GOARCH":
  
  41
  >
  			InfoData.GoArch = setting.Value
  
  42
  >
  		case "GOOS":
  
  43
  >
  			InfoData.GoOs = setting.Value
  
  44
  >
  		case "CGO_ENABLED":
  
  45
  >
  			InfoData.CgoEnabled = setting.Value == "1"
  
  46
  
  		case "vcs.revision":
  
  47
  
  			InfoData.GitRevision = setting.Value

go.temporal.io/server/common/dynamicconfig/gradual_change.go 14 covered LOC · 3 ranges

Open complete file

  25
  
  // StaticGradualChange returns a GradualChange whose Value always returns def and whose When
  
  26
  
  // always returns a time in the past.
  
  27
  >
  func StaticGradualChange[T any](def T) GradualChange[T] {
  
gradual_change.go

  28
  >
  	return GradualChange[T]{New: def}
  
  29
  >
  }
  
  30
  
  31
  
  // Value returns the value for the given key at the given time.

  56
  
  // of type GradualChange into a GradualChange.
  
  57
  
  // nolint:revive // cognitive-complexity // this looks complicated but each case is fairly simple
  
  58
  >
  func ConvertGradualChange[T any](def T) func(v any) (GradualChange[T], error) {
  
gradual_change.go

  59
  >
  	changeConverter := ConvertStructure(StaticGradualChange(def))
  
  60
  >
  
  61
  >
  	// Call this once so that if it's going to panic, it panics at static init time.
  
  62
  >
  	_, _ = changeConverter(nil)
  
  63
  >
  
  64
  >
  	switch reflect.TypeFor[T]() {
  
  65
  >
  	case reflect.TypeFor[bool]():
  
  66
  >
  		return func(v any) (GradualChange[T], error) {
  
  67
  
  			if b, err := convertBool(v); err == nil {
  
  68
  
  				var change GradualChange[T]

  72
  
  			return changeConverter(v)
  
  73
  
  		}
  
  74
  >
  	case reflect.TypeFor[int]():
  
gradual_change.go

  75
  >
  		return func(v any) (GradualChange[T], error) {
  
  76
  
  			if i, err := convertInt(v); err == nil {
  
  77
  
  				var change GradualChange[T]

go.temporal.io/server/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/service/history/api/workflow_lease.go 13 covered LOC · 3 ranges

Open complete file

  45
  
  	releaseFn historyi.ReleaseWorkflowContextFunc,
  
  46
  
  	mutableState historyi.MutableState,
  
  47
  >
  ) WorkflowLease {
  
workflow_lease.go

  48
  >
  	return &workflowLease{
  
  49
  >
  		context:      wfContext,
  
  50
  >
  		releaseFn:    releaseFn,
  
  51
  >
  		mutableState: mutableState,
  
  52
  >
  	}
  
  53
  >
  }
  
  54
  
  55
  
  func (w *workflowLease) GetContext() historyi.WorkflowContext {

  57
  
  }
  
  58
  
  59
  >
  func (w *workflowLease) GetMutableState() historyi.MutableState {
  
workflow_lease.go

  60
  >
  	return w.mutableState
  
  61
  >
  }
  
  62
  
  63
  >
  func (w *workflowLease) GetReleaseFn() historyi.ReleaseWorkflowContextFunc {
  
workflow_lease.go

  64
  >
  	return w.releaseFn
  
  65
  >
  }

go.temporal.io/server/service/history/workflow/query_registry.go 13 covered LOC · 3 ranges

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 {

  152
  
  }
  
  153
  
  154
  >
  func (r *queryRegistryImpl) Clear() {
  
query_registry.go

  155
  >
  	r.Lock()
  
  156
  >
  	defer r.Unlock()
  
  157
  >
  	for id, q := range r.buffered {
  
  158
  
  		_ = q.setCompletionState(&historyi.QueryCompletionState{
  
  159
  
  			Type: QueryCompletionTypeFailed,

  162
  
  		r.failed[id] = q
  
  163
  
  	}
  
  164
  >
  	r.buffered = make(map[string]query)
  
query_registry.go

  165
  
  }
  
  166

go.temporal.io/server/chasm/library.go 12 covered LOC · 4 ranges

Open complete file

  34
  
  }
  
  35
  
  36
  >
  func (UnimplementedLibrary) Tasks() []*RegistrableTask {
  
library.go

  37
  >
  	return nil
  
  38
  >
  }
  
  39
  
  40
  
  // RegisterServices Registers the gRPC calls to the handlers of the library.

  42
  
  }
  
  43
  
  44
  >
  func (UnimplementedLibrary) NexusServices() []*nexus.Service {
  
library.go

  45
  >
  	return nil
  
  46
  >
  }
  
  47
  
  48
  >
  func (UnimplementedLibrary) NexusServiceProcessors() []*NexusServiceProcessor {
  
library.go

  49
  >
  	return nil
  
  50
  >
  }
  
  51
  
  52
  
  func (UnimplementedLibrary) mustEmbedUnimplementedLibrary() {}

  56
  
  // tasks within the CHASM framework.
  
  57
  
  // The format of the returned FQN is: "libName.name"
  
  58
  >
  func FullyQualifiedName(libName, name string) string {
  
library.go

  59
  >
  	return libName + "." + name
  
  60
  >
  }

go.temporal.io/server/common/metrics/noop_impl.go 12 covered LOC · 6 ranges

Open complete file

  15
  
  )
  
  16
  
  17
  >
  func newNoopMetricsHandler() *noopMetricsHandler { return &noopMetricsHandler{} }
  
noop_impl.go

  18
  
  19
  
  // WithTags creates a new MetricProvder with provided []Tag
  
  20
  
  // Tags are merged with registered Tags from the source MetricsHandler
  
  21
  >
  func (n *noopMetricsHandler) WithTags(...Tag) Handler {
  
noop_impl.go

  22
  >
  	return n
  
  23
  >
  }
  
  24
  
  25
  
  // Counter obtains a counter for the given name.

  29
  
  30
  
  // Gauge obtains a gauge for the given name.
  
  31
  >
  func (*noopMetricsHandler) Gauge(string) GaugeIface {
  
noop_impl.go

  32
  >
  	return NoopGaugeMetricFunc
  
  33
  >
  }
  
  34
  
  35
  
  // Timer obtains a timer for the given name.
  
  36
  >
  func (*noopMetricsHandler) Timer(string) TimerIface {
  
noop_impl.go

  37
  >
  	return NoopTimerMetricFunc
  
  38
  >
  }
  
  39
  
  40
  
  // Histogram obtains a histogram for the given name.

  54
  
  55
  
  var NoopCounterMetricFunc = CounterFunc(func(i int64, t ...Tag) {})
  
  56
  >
  var NoopGaugeMetricFunc = GaugeFunc(func(f float64, t ...Tag) {})
  
noop_impl.go

  57
  >
  var NoopTimerMetricFunc = TimerFunc(func(d time.Duration, t ...Tag) {})
  
noop_impl.go

  58
  
  var NoopHistogramMetricFunc = HistogramFunc(func(i int64, t ...Tag) {})

go.temporal.io/server/common/persistence/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/service/history/tasks/key.go 12 covered LOC · 2 ranges

Open complete file

  28
  
  )
  
  29
  
  30
  >
  func NewImmediateKey(taskID int64) Key {
  
key.go

  31
  >
  	return Key{
  
  32
  >
  		FireTime: DefaultFireTime,
  
  33
  >
  		TaskID:   taskID,
  
  34
  >
  	}
  
  35
  >
  }
  
  36
  
  37
  >
  func NewKey(fireTime time.Time, taskID int64) Key {
  
key.go

  38
  >
  	return Key{
  
  39
  >
  		FireTime: fireTime,
  
  40
  >
  		TaskID:   taskID,
  
  41
  >
  	}
  
  42
  >
  }
  
  43
  
  44
  
  func ValidateKey(key Key) error {

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

Open complete file

  63
  
  64
  
  // NewDefaultHandoverTrackerFactory returns a factory that creates the default OSS HandoverTracker.
  
  65
  >
  func NewDefaultHandoverTrackerFactory() HandoverTrackerFactory {
  
handover_tracker.go

  66
  >
  	return func(params HandoverTrackerParams) HandoverTracker {
  
  67
  >
  		return &defaultHandoverTracker{
  
handover_tracker.go

  68
  >
  			handoverNamespaces:      make(map[namespace.Name]*namespaceHandOverInfo),
  
  69
  >
  			clusterMetadata:         params.ClusterMetadata,
  
  70
  >
  			getMaxReplicationTaskID: params.GetMaxReplicationTaskID,
  
  71
  >
  			errorByStateFn:          params.ErrorByStateFn,
  
  72
  >
  			notifyReplicationFn:     params.NotifyReplicationFn,
  
  73
  >
  			logger:                  params.Logger,
  
  74
  >
  		}
  
  75
  >
  	}
  
  76
  
  }
  
  77

go.temporal.io/server/service/history/tests/vars.go 11 covered LOC · 1 range

Open complete file

  158
  
  )
  
  159
  
  160
  >
  func NewDynamicConfig() *configs.Config {
  
vars.go

  161
  >
  	dc := dynamicconfig.NewNoopCollection()
  
  162
  >
  	config := configs.NewConfig(dc, 1)
  
  163
  >
  	config.EnableActivityEagerExecution = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)
  
  164
  >
  	config.NamespaceCacheRefreshInterval = dynamicconfig.GetDurationPropertyFn(time.Second)
  
  165
  >
  	config.ReplicationEnableUpdateWithNewTaskMerge = dynamicconfig.GetBoolPropertyFn(true)
  
  166
  >
  	config.EnableWorkflowIdReuseStartTimeValidation = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)
  
  167
  >
  	config.EnableTransitionHistory = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(true)
  
  168
  >
  	config.EnableChasm = dynamicconfig.GetBoolPropertyFnFilteredByNamespace(false)
  
  169
  >
  	return config
  
  170
  >
  }

go.temporal.io/server/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/api/persistence/v1/chasm.go-helpers.pb.go 9 covered LOC · 3 ranges

Open complete file

  17
  
  18
  
  // Size returns the size of the object, in bytes, once serialized
  
  19
  >
  func (val *ChasmNode) Size() int {
  
chasm.go-helpers.pb.go

  20
  >
  	return proto.Size(val)
  
  21
  >
  }
  
  22
  
  23
  
  // Equal returns whether two ChasmNode values are equivalent by recursively

  340
  
  341
  
  // Marshal an object of type ChasmComponentRef to the protobuf v3 wire format
  
  342
  >
  func (val *ChasmComponentRef) Marshal() ([]byte, error) {
  
chasm.go-helpers.pb.go

  343
  >
  	return proto.Marshal(val)
  
  344
  >
  }
  
  345
  
  346
  
  // Unmarshal an object of type ChasmComponentRef from the protobuf v3 wire format
  
  347
  >
  func (val *ChasmComponentRef) Unmarshal(buf []byte) error {
  
chasm.go-helpers.pb.go

  348
  >
  	return proto.Unmarshal(buf, val)
  
  349
  >
  }
  
  350
  
  351
  
  // Size returns the size of the object, in bytes, once serialized

go.temporal.io/server/chasm/visibility.go 9 covered LOC · 1 range

Open complete file

  64
  
  65
  
  // newVisibilitySearchAttributesMapper returns a mapper with all maps initialized.
  
  66
  >
  func newVisibilitySearchAttributesMapper() *VisibilitySearchAttributesMapper {
  
visibility.go

  67
  >
  	return &VisibilitySearchAttributesMapper{
  
  68
  >
  		aliasToField:           make(map[string]string),
  
  69
  >
  		fieldToAlias:           make(map[string]string),
  
  70
  >
  		saTypeMap:              make(map[string]enumspb.IndexedValueType),
  
  71
  >
  		systemAliasToField:     make(map[string]string),
  
  72
  >
  		overriddenSystemFields: make(map[string]enumspb.IndexedValueType),
  
  73
  >
  	}
  
  74
  >
  }
  
  75
  
  76
  
  // Alias returns the alias for a given field.

go.temporal.io/server/common/archiver/archival_metadata.go 9 covered LOC · 1 range

Open complete file

  127
  
  128
  
  // NewDisabledArchvialConfig returns an ArchivalConfig where archival is disabled for both the cluster and the namespace
  
  129
  >
  func NewDisabledArchvialConfig() ArchivalConfig {
  
archival_metadata.go

  130
  >
  	return &archivalConfig{
  
  131
  >
  		staticClusterState:    ArchivalDisabled,
  
  132
  >
  		dynamicClusterState:   nil,
  
  133
  >
  		enableRead:            nil,
  
  134
  >
  		namespaceDefaultState: enumspb.ARCHIVAL_STATE_DISABLED,
  
  135
  >
  		namespaceDefaultURI:   "",
  
  136
  >
  	}
  
  137
  >
  }
  
  138
  
  139
  
  // NewEnabledArchivalConfig returns an ArchivalConfig where archival is enabled for both the cluster and the namespace

go.temporal.io/server/common/dynamicconfig/static_client.go 9 covered LOC · 4 ranges

Open complete file

  10
  
  )
  
  11
  
  12
  >
  func (s StaticClient) GetValue(key Key) []ConstrainedValue {
  
static_client.go

  13
  >
  	if v, ok := s[key]; ok {
  
  14
  
  		if cvs, ok := v.([]ConstrainedValue); ok {
  
  15
  
  			return cvs

  17
  
  		return []ConstrainedValue{{Value: v}}
  
  18
  
  	}
  
  19
  >
  	return nil
  
static_client.go

  20
  
  }
  
  21
  
  22
  
  // NewNoopClient returns a Client that has no keys (a Collection using it will always return
  
  23
  
  // default values).
  
  24
  >
  func NewNoopClient() Client {
  
static_client.go

  25
  >
  	return StaticClient(nil)
  
  26
  >
  }
  
  27
  
  28
  
  // NewNoopCollection creates a new noop collection.
  
  29
  >
  func NewNoopCollection() *Collection {
  
static_client.go

  30
  >
  	return NewCollection(NewNoopClient(), log.NewNoopLogger())
  
  31
  >
  }

go.temporal.io/server/common/persistence/sql/sqlplugin/util.go 9 covered LOC · 2 ranges

Open complete file

  5
  
  )
  
  6
  
  7
  >
  func appendPrefix(prefix string, fields []string) []string {
  
util.go

  8
  >
  	out := make([]string, len(fields))
  
  9
  >
  	for i, field := range fields {
  
  10
  >
  		out[i] = prefix + field
  
  11
  >
  	}
  
  12
  >
  	return out
  
  13
  
  }
  
  14
  
  15
  >
  func BuildNamedPlaceholder(fields ...string) string {
  
util.go

  16
  >
  	return strings.Join(appendPrefix(":", fields), ", ")
  
  17
  >
  }

go.temporal.io/server/common/testing/testhooks/test_impl.go 9 covered LOC · 2 ranges

Open complete file

  89
  
  var keyCounter atomic.Int64
  
  90
  
  91
  >
  func newKey[T any, S any]() Key[T, S] {
  
test_impl.go

  92
  >
  	var zero S
  
  93
  >
  	var s ScopeType
  
  94
  >
  	switch any(zero).(type) {
  
  95
  >
  	case namespace.ID, namespace.Name:
  
  96
  >
  		s = ScopeNamespace
  
  97
  >
  	case global:
  
  98
  >
  		s = ScopeGlobal
  
  99
  
  	default:
  
  100
  
  		panic("testhooks: unknown scope type")
  
  101
  
  	}
  
  102
  >
  	return Key[T, S]{id: keyCounter.Add(1), scopeType: s}
  
test_impl.go

  103
  
  }

go.temporal.io/server/common/testing/testvars/any.go 9 covered LOC · 2 ranges

Open complete file

  18
  
  }
  
  19
  
  20
  >
  func newAny(testName string, testHash uint32) Any {
  
any.go

  21
  >
  	return Any{
  
  22
  >
  		testName: testName,
  
  23
  >
  		testHash: testHash,
  
  24
  >
  	}
  
  25
  >
  }
  
  26
  
  27
  
  func (a Any) String() string {

  77
  
  }
  
  78
  
  79
  >
  func (a Any) RunID() string {
  
any.go

  80
  >
  	return uuid.NewString()
  
  81
  >
  }
  
  82
  
  83
  
  func (a Any) WorkflowKey() definition.WorkflowKey {

go.temporal.io/server/service/history/tasks/category.go 9 covered LOC · 3 ranges

Open complete file

  96
  
  }
  
  97
  
  98
  >
  func (c Category) ID() int {
  
category.go

  99
  >
  	return c.id
  
  100
  >
  }
  
  101
  
  102
  >
  func (c Category) Name() string {
  
category.go

  103
  >
  	return c.name
  
  104
  >
  }
  
  105
  
  106
  >
  func (c Category) Type() CategoryType {
  
category.go

  107
  >
  	return c.cType
  
  108
  >
  }
  
  109
  
  110
  
  func (c Category) MarshalText() (text []byte, err error) {

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

Open complete file

  25
  
  26
  
  // Serialize is a noop as Deserialize is not supported.
  
  27
  >
  func (stateMachineDefinition) Serialize(any) ([]byte, error) {
  
state_machine_definition.go

  28
  >
  	return nil, nil
  
  29
  >
  }
  
  30
  
  31
  >
  func (stateMachineDefinition) Type() string {
  
state_machine_definition.go

  32
  >
  	return StateMachineType
  
  33
  >
  }
  
  34
  
  35
  >
  func RegisterStateMachine(reg *hsm.Registry) error {
  
state_machine_definition.go

  36
  >
  	return reg.RegisterMachine(stateMachineDefinition{})
  
  37
  >
  }

go.temporal.io/server/service/history/workflow/task_generator.go 9 covered LOC · 1 range

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(

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

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 {

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/persistence/versionhistory/version_histories.go 6 covered LOC · 2 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

go.temporal.io/server/service/history/configs/task.go 6 covered LOC · 1 range

Open complete file

  26
  
  func ConvertWeightsToDynamicConfigValue(
  
  27
  
  	weights map[tasks.Priority]int,
  
  28
  >
  ) map[string]any {
  
task.go

  29
  >
  	weightsForDC := make(map[string]any)
  
  30
  >
  	for priority, weight := range weights {
  
  31
  >
  		weightsForDC[priority.String()] = weight
  
  32
  >
  	}
  
  33
  >
  	return weightsForDC
  
  34
  
  }
  
  35

go.temporal.io/server/service/history/historybuilder/event_store.go 6 covered LOC · 1 range

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 {

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/component.go 5 covered LOC · 2 ranges

Open complete file

  128
  
  func operationIntentFromContext(
  
  129
  
  	ctx context.Context,
  
  130
  >
  ) OperationIntent {
  
component.go

  131
  >
  	intent, ok := ctx.Value(operationIntentCtxKey).(OperationIntent)
  
  132
  >
  	if !ok {
  
  133
  >
  		return OperationIntentUnspecified
  
component.go

  134
  >
  	}
  
  135
  
  	return intent
  
  136
  
  }

go.temporal.io/server/chasm/lib/nexusoperation/config.go 5 covered LOC · 1 range

Open complete file

  160
  
  }
  
  161
  
  162
  >
  func (cfg RetryPolicyConfig) build() backoff.RetryPolicy {
  
config.go

  163
  >
  	return backoff.NewExponentialRetryPolicy(cfg.InitialInterval).
  
  164
  >
  		WithMaximumInterval(cfg.MaxInterval).
  
  165
  >
  		WithExpirationInterval(backoff.NoInterval)
  
  166
  >
  }
  
  167
  
  168
  
  var defaultRetryPolicyConfig = RetryPolicyConfig{

go.temporal.io/server/chasm/lib/scheduler/util.go 5 covered LOC · 1 range

Open complete file

  26
  
  27
  
  // serializeConflictToken serializes a conflict token as a byte slice.
  
  28
  >
  func serializeConflictToken(conflictToken int64) []byte {
  
util.go

  29
  >
  	token := make([]byte, 8)
  
  30
  >
  	binary.LittleEndian.PutUint64(token, uint64(conflictToken))
  
  31
  >
  	return token
  
  32
  >
  }
  
  33
  
  34
  
  // newTaggedLogger returns a logger tagged with the Scheduler's attributes.

go.temporal.io/server/chasm/nexus_operation_processor.go 5 covered LOC · 1 range

Open complete file

  165
  
  166
  
  // NewNexusEndpointProcessor creates a new NexusEndpointProcessor.
  
  167
  >
  func NewNexusEndpointProcessor() *NexusEndpointProcessor {
  
nexus_operation_processor.go

  168
  >
  	return &NexusEndpointProcessor{
  
  169
  >
  		serviceProcessors: make(map[string]*NexusServiceProcessor),
  
  170
  >
  	}
  
  171
  >
  }
  
  172
  
  173
  
  // RegisterServiceProcessor adds a service-level processor to the endpoint keyed by its name.

go.temporal.io/server/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/sql/sqlplugin/mysql/plugin.go 5 covered LOC · 1 range

Open complete file

  24
  
  var _ sqlplugin.Plugin = (*plugin)(nil)
  
  25
  
  26
  >
  func init() {
  
plugin.go

  27
  >
  	sql.RegisterPlugin(PluginName, &plugin{
  
  28
  >
  		queryConverter: &queryConverter{},
  
  29
  >
  	})
  
  30
  >
  }
  
  31
  
  32
  
  func (p *plugin) GetVisibilityQueryConverter() sqlplugin.VisibilityQueryConverter {

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/conn_pool.go 5 covered LOC · 1 range

Open complete file

  23
  
  }
  
  24
  
  25
  >
  func newConnPool() *connPool {
  
conn_pool.go

  26
  >
  	return &connPool{
  
  27
  >
  		pool: make(map[string]entry),
  
  28
  >
  	}
  
  29
  >
  }
  
  30
  
  31
  
  // Allocate allocates the shared database in the pool or returns already exists instance with the same DSN. If instance

go.temporal.io/server/common/persistence/visibility/manager/visibility_manager_mock.go 5 covered LOC · 1 range

Open complete file

  32
  
  33
  
  // NewMockVisibilityManager creates a new mock instance.
  
  34
  >
  func NewMockVisibilityManager(ctrl *gomock.Controller) *MockVisibilityManager {
  
visibility_manager_mock.go

  35
  >
  	mock := &MockVisibilityManager{ctrl: ctrl}
  
  36
  >
  	mock.recorder = &MockVisibilityManagerMockRecorder{mock}
  
  37
  >
  	return mock
  
  38
  >
  }
  
  39
  
  40
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/persistence/visibility/store/elasticsearch/client/client_mock.go 5 covered LOC · 1 range

Open complete file

  32
  
  33
  
  // NewMockClient creates a new mock instance.
  
  34
  >
  func NewMockClient(ctrl *gomock.Controller) *MockClient {
  
client_mock.go

  35
  >
  	mock := &MockClient{ctrl: ctrl}
  
  36
  >
  	mock.recorder = &MockClientMockRecorder{mock}
  
  37
  >
  	return mock
  
  38
  >
  }
  
  39
  
  40
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/sdk/factory_mock.go 5 covered LOC · 1 range

Open complete file

  31
  
  32
  
  // NewMockClientFactory creates a new mock instance.
  
  33
  >
  func NewMockClientFactory(ctrl *gomock.Controller) *MockClientFactory {
  
factory_mock.go

  34
  >
  	mock := &MockClientFactory{ctrl: ctrl}
  
  35
  >
  	mock.recorder = &MockClientFactoryMockRecorder{mock}
  
  36
  >
  	return mock
  
  37
  >
  }
  
  38
  
  39
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/searchattribute/mapper_mock.go 5 covered LOC · 1 range

Open complete file

  84
  
  85
  
  // NewMockMapperProvider creates a new mock instance.
  
  86
  >
  func NewMockMapperProvider(ctrl *gomock.Controller) *MockMapperProvider {
  
mapper_mock.go

  87
  >
  	mock := &MockMapperProvider{ctrl: ctrl}
  
  88
  >
  	mock.recorder = &MockMapperProviderMockRecorder{mock}
  
  89
  >
  	return mock
  
  90
  >
  }
  
  91
  
  92
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go 5 covered LOC · 1 range

Open complete file

  32
  
  33
  
  // NewMockWorkflowServiceClient creates a new mock instance.
  
  34
  >
  func NewMockWorkflowServiceClient(ctrl *gomock.Controller) *MockWorkflowServiceClient {
  
service_grpc.pb.mock.go

  35
  >
  	mock := &MockWorkflowServiceClient{ctrl: ctrl}
  
  36
  >
  	mock.recorder = &MockWorkflowServiceClientMockRecorder{mock}
  
  37
  >
  	return mock
  
  38
  >
  }
  
  39
  
  40
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/common/testing/testvars/hash.go 5 covered LOC · 1 range

Open complete file

  5
  
  )
  
  6
  
  7
  >
  func hash(s string) uint32 {
  
hash.go

  8
  >
  	h := fnv.New32a()
  
  9
  >
  	_, _ = h.Write([]byte(s))
  
  10
  >
  	return h.Sum32()
  
  11
  >
  }

go.temporal.io/server/service/history/chasm_notifier.go 5 covered LOC · 1 range

Open complete file

  21
  
  22
  
  // NewChasmNotifier creates a new instance of ChasmNotifier.
  
  23
  >
  func NewChasmNotifier() *ChasmNotifier {
  
chasm_notifier.go

  24
  >
  	return &ChasmNotifier{
  
  25
  >
  		executions: make(map[chasm.ExecutionKey]*subscriptionTracker),
  
  26
  >
  	}
  
  27
  >
  }
  
  28
  
  29
  
  // Subscribe returns a channel that will be closed when there is a notification relating to the

go.temporal.io/server/service/history/events/events_cache_mock.go 5 covered LOC · 1 range

Open complete file

  31
  
  32
  
  // NewMockCache creates a new mock instance.
  
  33
  >
  func NewMockCache(ctrl *gomock.Controller) *MockCache {
  
events_cache_mock.go

  34
  >
  	mock := &MockCache{ctrl: ctrl}
  
  35
  >
  	mock.recorder = &MockCacheMockRecorder{mock}
  
  36
  >
  	return mock
  
  37
  >
  }
  
  38
  
  39
  
  // EXPECT returns an object that allows the caller to indicate expected use.

go.temporal.io/server/chasm/path_encoder.go 4 covered LOC · 1 range

Open complete file

  92
  
  func (e *defaultPathEncoder) Decode(
  
  93
  
  	encodedPath string,
  
  94
  >
  ) ([]string, error) {
  
path_encoder.go

  95
  >
  	if encodedPath == "" {
  
  96
  >
  		return rootPath, nil
  
  97
  >
  	}
  
  98
  
  99
  
  	path := make([]string, 0, 3)

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

Open complete file

  68
  
  69
  
  // InverseMap creates the inverse map, ie., for a key-value map, it builds the value-key map.
  
  70
  >
  func InverseMap[M ~map[K]V, K, V comparable](m M) map[V]K {
  
util.go

  71
  >
  	if m == nil {
  
  72
  >
  		return nil
  
  73
  >
  	}
  
  74
  
  	invm := make(map[V]K, len(m))
  
  75
  
  	for k, v := range m {

go.temporal.io/server/api/persistence/v1/predicates.go-helpers.pb.go 3 covered LOC · 1 range

Open complete file

  17
  
  18
  
  // Size returns the size of the object, in bytes, once serialized
  
  19
  >
  func (val *Predicate) Size() int {
  
predicates.go-helpers.pb.go

  20
  >
  	return proto.Size(val)
  
  21
  >
  }
  
  22
  
  23
  
  // Equal returns whether two Predicate values are equivalent by recursively

go.temporal.io/server/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/testing/protorequire/require.go 3 covered LOC · 1 range

Open complete file

  38
  
  }
  
  39
  
  40
  >
  func New(t require.TestingT) ProtoAssertions {
  
require.go

  41
  >
  	return ProtoAssertions{t}
  
  42
  >
  }
  
  43
  
  44
  
  // ProtoEqual compares two proto messages for equality using proto semantics. Options can be passed to customize

go.temporal.io/server/service/history/consts/const.go 3 covered LOC · 1 range

Open complete file

  152
  
  }
  
  153
  
  154
  >
  func (staleStateError) Error() string {
  
const.go

  155
  >
  	return "cached mutable state could potentially be stale"
  
  156
  >
  }
  
  157
  
  158
  
  // IsTerminalTaskError marks this error as terminal to be handled appropriately.

go.temporal.io/server/service/history/queues/errors/errors.go 3 covered LOC · 1 range

Open complete file

  39
  
  40
  
  // NewUnprocessableTaskError returns a new UnprocessableTaskError from given message.
  
  41
  >
  func NewUnprocessableTaskError(message string) *UnprocessableTaskError {
  
errors.go

  42
  >
  	return &UnprocessableTaskError{Message: message}
  
  43
  >
  }
  
  44
  
  45
  
  func (e UnprocessableTaskError) Error() string {

go.temporal.io/server/common/persistence/client/fx.go 2 covered LOC · 1 range

Open complete file

  224
  
  }
  
  225
  
  226
  >
  func managerProvider[T persistence.Closeable](newManagerFn func(Factory) (T, error)) func(Factory, fx.Lifecycle) (T, error) {
  
fx.go

  227
  >
  	return func(f Factory, lc fx.Lifecycle) (T, error) {
  
  228
  
  		manager, err := newManagerFn(f) // passing receiver (Factory) as first argument.
  
  229
  
  		if err != nil {

go.temporal.io/server/common/aggregate/noop_moving_window_average.go 1 covered LOC · 1 range

Open complete file

  7
  
  )
  
  8
  
  9
  >
  func newNoopMovingWindowAverage() *noopMovingWindowAverage { return &noopMovingWindowAverage{} }
  
noop_moving_window_average.go

  10
  
  11
  
  func (a *noopMovingWindowAverage) Record(_ int64) {}

go.temporal.io/server/common/persistence/noop_health_signal_aggregator.go 1 covered LOC · 1 range

Open complete file

  11
  
  )
  
  12
  
  13
  >
  func newNoopSignalAggregator() *noopSignalAggregator { return &noopSignalAggregator{} }
  
noop_health_signal_aggregator.go

  14
  
  15
  
  func (a *noopSignalAggregator) Start() {}

TestPollComponent_StaleState

Covered source