TestProcessMessage_TrackSubmit_SingleStack

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/common/dynamicconfig/setting_gen.go 290 covered LOC · 67 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
  
  1110
  
  	}

  1134
  
  1135
  
  // NewNamespaceIDTypedSettingWithConverter creates a setting with a custom converter function.
  
  1136
  >
  func NewNamespaceIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) NamespaceIDTypedSetting[T] {
  
setting_gen.go

  1137
  >
  	s := NamespaceIDTypedSetting[T]{
  
  1138
  >
  		key:         MakeKey(key),
  
  1139
  >
  		def:         def,
  
  1140
  >
  		convert:     convert,
  
  1141
  >
  		description: description,
  
  1142
  >
  	}
  
  1143
  >
  	register(s)
  
  1144
  >
  	return s
  
  1145
  >
  }
  
  1146
  
  1147
  
  // NewNamespaceIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1157
  
  }
  
  1158
  
  1159
  >
  func (s NamespaceIDTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1160
  
  func (s NamespaceIDTypedSetting[T]) Precedence() Precedence { return PrecedenceNamespaceID }
  
  1161
  
  func (s NamespaceIDTypedSetting[T]) Validate(v any) error {

  1179
  
  type TypedPropertyFnWithNamespaceIDFilter[T any] func(namespaceID namespace.ID) T
  
  1180
  
  1181
  >
  func (s NamespaceIDTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithNamespaceIDFilter[T] {
  
setting_gen.go

  1182
  >
  	return func(namespaceID namespace.ID) T {
  
  1183
  
  		prec := []Constraints{{NamespaceID: namespaceID.String()}, {}}
  
  1184
  
  		return matchAndConvert(

  1253
  
  // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful
  
  1254
  
  // when using non-empty maps or slices as defaults, the result may not be what you want.
  
  1255
  >
  func NewTaskQueueTypedSetting[T any](key string, def T, description string) TaskQueueTypedSetting[T] {
  
setting_gen.go

  1256
  >
  	// Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.
  
  1257
  >
  	warnDefaultSharedStructure(key, def)
  
  1258
  >
  	// If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.
  
  1259
  >
  	_ = deepCopyForMapstructure(def)
  
  1260
  >
  
  1261
  >
  	s := TaskQueueTypedSetting[T]{
  
  1262
  >
  		key:         MakeKey(key),
  
  1263
  >
  		def:         def,
  
  1264
  >
  		convert:     ConvertStructure[T](def),
  
  1265
  >
  		description: description,
  
  1266
  >
  	}
  
  1267
  >
  	register(s)
  
  1268
  >
  	return s
  
  1269
  >
  }
  
  1270
  
  1271
  
  // NewTaskQueueTypedSettingWithConverter creates a setting with a custom converter function.
  
  1272
  >
  func NewTaskQueueTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskQueueTypedSetting[T] {
  
setting_gen.go

  1273
  >
  	s := TaskQueueTypedSetting[T]{
  
  1274
  >
  		key:         MakeKey(key),
  
  1275
  >
  		def:         def,
  
  1276
  >
  		convert:     convert,
  
  1277
  >
  		description: description,
  
  1278
  >
  	}
  
  1279
  >
  	register(s)
  
  1280
  >
  	return s
  
  1281
  >
  }
  
  1282
  
  1283
  
  // NewTaskQueueTypedSettingWithConstrainedDefault creates a setting with a compound default value.
  
  1284
  >
  func NewTaskQueueTypedSettingWithConstrainedDefault[T any](key string, convert func(any) (T, error), cdef []TypedConstrainedValue[T], description string) TaskQueueTypedConstrainedDefaultSetting[T] {
  
setting_gen.go

  1285
  >
  	s := TaskQueueTypedConstrainedDefaultSetting[T]{
  
  1286
  >
  		key:         MakeKey(key),
  
  1287
  >
  		cdef:        cdef,
  
  1288
  >
  		convert:     convert,
  
  1289
  >
  		description: description,
  
  1290
  >
  	}
  
  1291
  >
  	register(s)
  
  1292
  >
  	return s
  
  1293
  >
  }
  
  1294
  
  1295
  >
  func (s TaskQueueTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1296
  
  func (s TaskQueueTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }
  
  1297
  
  func (s TaskQueueTypedSetting[T]) Validate(v any) error {

  1300
  
  }
  
  1301
  
  1302
  >
  func (s TaskQueueTypedConstrainedDefaultSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1303
  
  func (s TaskQueueTypedConstrainedDefaultSetting[T]) Precedence() Precedence { return PrecedenceTaskQueue }
  
  1304
  
  func (s TaskQueueTypedConstrainedDefaultSetting[T]) Validate(v any) error {

  1315
  
  type TypedPropertyFnWithTaskQueueFilter[T any] func(namespace string, taskQueue string, taskQueueType enumspb.TaskQueueType) T
  
  1316
  
  1317
  >
  func (s TaskQueueTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithTaskQueueFilter[T] {
  
setting_gen.go

  1318
  >
  	return func(namespace string, taskQueue string, taskQueueType enumspb.TaskQueueType) T {
  
  1319
  
  		prec := []Constraints{
  
  1320
  
  			{Namespace: namespace, TaskQueueName: taskQueue, TaskQueueType: taskQueueType},

  1430
  
  1431
  
  // NewShardIDTypedSettingWithConverter creates a setting with a custom converter function.
  
  1432
  >
  func NewShardIDTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ShardIDTypedSetting[T] {
  
setting_gen.go

  1433
  >
  	s := ShardIDTypedSetting[T]{
  
  1434
  >
  		key:         MakeKey(key),
  
  1435
  >
  		def:         def,
  
  1436
  >
  		convert:     convert,
  
  1437
  >
  		description: description,
  
  1438
  >
  	}
  
  1439
  >
  	register(s)
  
  1440
  >
  	return s
  
  1441
  >
  }
  
  1442
  
  1443
  
  // NewShardIDTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1453
  
  }
  
  1454
  
  1455
  >
  func (s ShardIDTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1456
  
  func (s ShardIDTypedSetting[T]) Precedence() Precedence { return PrecedenceShardID }
  
  1457
  
  func (s ShardIDTypedSetting[T]) Validate(v any) error {

  1475
  
  type TypedPropertyFnWithShardIDFilter[T any] func(shardID int32) T
  
  1476
  
  1477
  >
  func (s ShardIDTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithShardIDFilter[T] {
  
setting_gen.go

  1478
  >
  	return func(shardID int32) T {
  
  1479
  
  		prec := []Constraints{{ShardID: shardID}, {}}
  
  1480
  
  		return matchAndConvert(

  1566
  
  1567
  
  // NewTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.
  
  1568
  >
  func NewTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) TaskTypeTypedSetting[T] {
  
setting_gen.go

  1569
  >
  	s := TaskTypeTypedSetting[T]{
  
  1570
  >
  		key:         MakeKey(key),
  
  1571
  >
  		def:         def,
  
  1572
  >
  		convert:     convert,
  
  1573
  >
  		description: description,
  
  1574
  >
  	}
  
  1575
  >
  	register(s)
  
  1576
  >
  	return s
  
  1577
  >
  }
  
  1578
  
  1579
  
  // NewTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1589
  
  }
  
  1590
  
  1591
  >
  func (s TaskTypeTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1592
  
  func (s TaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceTaskType }
  
  1593
  
  func (s TaskTypeTypedSetting[T]) Validate(v any) error {

  1611
  
  type TypedPropertyFnWithTaskTypeFilter[T any] func(taskType enumsspb.TaskType) T
  
  1612
  
  1613
  >
  func (s TaskTypeTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithTaskTypeFilter[T] {
  
setting_gen.go

  1614
  >
  	return func(taskType enumsspb.TaskType) T {
  
  1615
  
  		prec := []Constraints{{TaskType: taskType}, {}}
  
  1616
  
  		return matchAndConvert(

  1685
  
  // values. The value from dynamic config will be _merged_ over a deep copy of 'def'. Be very careful
  
  1686
  
  // when using non-empty maps or slices as defaults, the result may not be what you want.
  
  1687
  >
  func NewDestinationTypedSetting[T any](key string, def T, description string) DestinationTypedSetting[T] {
  
setting_gen.go

  1688
  >
  	// Warn on any shared structure used with ConvertStructure, even though we handle it by deep copying.
  
  1689
  >
  	warnDefaultSharedStructure(key, def)
  
  1690
  >
  	// If even deep copy won't even work, we should panic early. Do that by calling deep copy once here.
  
  1691
  >
  	_ = deepCopyForMapstructure(def)
  
  1692
  >
  
  1693
  >
  	s := DestinationTypedSetting[T]{
  
  1694
  >
  		key:         MakeKey(key),
  
  1695
  >
  		def:         def,
  
  1696
  >
  		convert:     ConvertStructure[T](def),
  
  1697
  >
  		description: description,
  
  1698
  >
  	}
  
  1699
  >
  	register(s)
  
  1700
  >
  	return s
  
  1701
  >
  }
  
  1702
  
  1703
  
  // NewDestinationTypedSettingWithConverter creates a setting with a custom converter function.
  
  1704
  >
  func NewDestinationTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) DestinationTypedSetting[T] {
  
setting_gen.go

  1705
  >
  	s := DestinationTypedSetting[T]{
  
  1706
  >
  		key:         MakeKey(key),
  
  1707
  >
  		def:         def,
  
  1708
  >
  		convert:     convert,
  
  1709
  >
  		description: description,
  
  1710
  >
  	}
  
  1711
  >
  	register(s)
  
  1712
  >
  	return s
  
  1713
  >
  }
  
  1714
  
  1715
  
  // NewDestinationTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1725
  
  }
  
  1726
  
  1727
  >
  func (s DestinationTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1728
  
  func (s DestinationTypedSetting[T]) Precedence() Precedence { return PrecedenceDestination }
  
  1729
  
  func (s DestinationTypedSetting[T]) Validate(v any) error {

  1747
  
  type TypedPropertyFnWithDestinationFilter[T any] func(namespace string, destination string) T
  
  1748
  
  1749
  >
  func (s DestinationTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithDestinationFilter[T] {
  
setting_gen.go

  1750
  >
  	return func(namespace string, destination string) T {
  
  1751
  
  		prec := []Constraints{
  
  1752
  
  			{Namespace: namespace, Destination: destination},

  1785
  
  type TypedSubscribableWithDestinationFilter[T any] func(namespace string, destination string, callback func(T)) (v T, cancel func())
  
  1786
  
  1787
  >
  func (s DestinationTypedSetting[T]) Subscribe(c *Collection) TypedSubscribableWithDestinationFilter[T] {
  
setting_gen.go

  1788
  >
  	return func(namespace string, destination string, callback func(T)) (T, func()) {
  
  1789
  
  		prec := []Constraints{
  
  1790
  
  			{Namespace: namespace, Destination: destination},

  1858
  
  1859
  
  // NewChasmTaskTypeTypedSettingWithConverter creates a setting with a custom converter function.
  
  1860
  >
  func NewChasmTaskTypeTypedSettingWithConverter[T any](key string, convert func(any) (T, error), def T, description string) ChasmTaskTypeTypedSetting[T] {
  
setting_gen.go

  1861
  >
  	s := ChasmTaskTypeTypedSetting[T]{
  
  1862
  >
  		key:         MakeKey(key),
  
  1863
  >
  		def:         def,
  
  1864
  >
  		convert:     convert,
  
  1865
  >
  		description: description,
  
  1866
  >
  	}
  
  1867
  >
  	register(s)
  
  1868
  >
  	return s
  
  1869
  >
  }
  
  1870
  
  1871
  
  // NewChasmTaskTypeTypedSettingWithConstrainedDefault creates a setting with a compound default value.

  1881
  
  }
  
  1882
  
  1883
  >
  func (s ChasmTaskTypeTypedSetting[T]) Key() Key               { return s.key }
  
setting_gen.go

  1884
  
  func (s ChasmTaskTypeTypedSetting[T]) Precedence() Precedence { return PrecedenceChasmTaskType }
  
  1885
  
  func (s ChasmTaskTypeTypedSetting[T]) Validate(v any) error {

  1903
  
  type TypedPropertyFnWithChasmTaskTypeFilter[T any] func(chasmTaskType string) T
  
  1904
  
  1905
  >
  func (s ChasmTaskTypeTypedSetting[T]) Get(c *Collection) TypedPropertyFnWithChasmTaskTypeFilter[T] {
  
setting_gen.go

  1906
  >
  	return func(chasmTaskType string) T {
  
  1907
  
  		prec := []Constraints{{ChasmTaskType: chasmTaskType}, {}}
  
  1908
  
  		return matchAndConvert(

go.temporal.io/server/service/history/replication/stream_receiver.go 122 covered LOC · 30 ranges

Open complete file

  71
  
  	ClusterID int32,
  
  72
  
  	ClusterShardID int32,
  
  73
  >
  ) ClusterShardKey {
  
stream_receiver.go

  74
  >
  	return ClusterShardKey{
  
  75
  >
  		ClusterID: ClusterID,
  
  76
  >
  		ShardID:   ClusterShardID,
  
  77
  >
  	}
  
  78
  >
  }
  
  79
  
  80
  
  func NewStreamReceiver(

  83
  
  	clientShardKey ClusterShardKey,
  
  84
  
  	serverShardKey ClusterShardKey,
  
  85
  >
  ) *StreamReceiverImpl {
  
stream_receiver.go

  86
  >
  	logger := log.With(
  
  87
  >
  		processToolBox.Logger,
  
  88
  >
  		tag.SourceCluster(processToolBox.ClusterMetadata.ClusterNameForFailoverVersion(true, int64(serverShardKey.ClusterID))),
  
  89
  >
  		tag.SourceShardID(serverShardKey.ShardID),
  
  90
  >
  		tag.ShardID(clientShardKey.ShardID), // client is the local cluster (target cluster, passive cluster)
  
  91
  >
  		tag.Operation("replication-stream-receiver"),
  
  92
  >
  	)
  
  93
  >
  	highPriorityTaskTracker := NewExecutableTaskTracker(logger, processToolBox.MetricsHandler)
  
  94
  >
  	lowPriorityTaskTracker := NewExecutableTaskTracker(logger, processToolBox.MetricsHandler)
  
  95
  >
  	receiver := &StreamReceiverImpl{
  
  96
  >
  		ProcessToolBox: processToolBox,
  
  97
  >
  
  98
  >
  		status:                  common.DaemonStatusInitialized,
  
  99
  >
  		clientShardKey:          clientShardKey,
  
  100
  >
  		serverShardKey:          serverShardKey,
  
  101
  >
  		highPriorityTaskTracker: highPriorityTaskTracker,
  
  102
  >
  		lowPriorityTaskTracker:  lowPriorityTaskTracker,
  
  103
  >
  		shutdownChan:            channel.NewShutdownOnce(),
  
  104
  >
  		logger:                  logger,
  
  105
  >
  		stream: newStream(
  
  106
  >
  			processToolBox,
  
  107
  >
  			clientShardKey,
  
  108
  >
  			serverShardKey,
  
  109
  >
  		),
  
  110
  >
  		taskConverter:            taskConverter,
  
  111
  >
  		receiverMode:             ReceiverModeUnset,
  
  112
  >
  		slowSubmissionTimestamps: make(map[enumsspb.TaskPriority]time.Time),
  
  113
  >
  		recvSignalChan:           make(chan struct{}, 1),
  
  114
  >
  	}
  
  115
  >
  	taskTrackerMap := make(map[enumsspb.TaskPriority]FlowControlSignalProvider)
  
  116
  >
  	taskTrackerMap[enumsspb.TASK_PRIORITY_HIGH] = func() *FlowControlSignal {
  
  117
  
  		return &FlowControlSignal{
  
  118
  
  			taskTrackingCount:  highPriorityTaskTracker.Size(),

  120
  
  		}
  
  121
  
  	}
  
  122
  >
  	taskTrackerMap[enumsspb.TASK_PRIORITY_LOW] = func() *FlowControlSignal {
  
stream_receiver.go

  123
  
  		return &FlowControlSignal{
  
  124
  
  			taskTrackingCount:  lowPriorityTaskTracker.Size(),

  126
  
  		}
  
  127
  
  	}
  
  128
  >
  	receiver.flowController = NewReceiverFlowControl(taskTrackerMap, processToolBox.Config)
  
stream_receiver.go

  129
  >
  	return receiver
  
  130
  
  }
  
  131

  322
  
  func (r *StreamReceiverImpl) processMessages(
  
  323
  
  	stream Stream,
  
  324
  >
  ) error {
  
stream_receiver.go

  325
  >
  	allClusterInfo := r.ClusterMetadata.GetAllClusterInfo()
  
  326
  >
  	clusterName, _, err := ClusterIDToClusterNameShardCount(allClusterInfo, r.serverShardKey.ClusterID)
  
  327
  >
  	if err != nil {
  
  328
  
  		return err
  
  329
  
  	}
  
  330
  
  331
  >
  	streamRespChen, err := stream.Recv()
  
stream_receiver.go

  332
  >
  	if err != nil {
  
  333
  
  		return NewStreamError("stream_receiver failed to recv", err)
  
  334
  
  	}
  
  335
  >
  	for streamResp := range streamRespChen {
  
stream_receiver.go

  336
  >
  		select {
  
  337
  >
  		case r.recvSignalChan <- struct{}{}:
  
  338
  
  		default:
  
  339
  
  			// signal channel is full. Continue
  
  340
  
  		}
  
  341
  >
  		if streamResp.Err != nil {
  
stream_receiver.go

  342
  
  			return streamResp.Err
  
  343
  
  		}
  
  344
  
  345
  >
  		messages := streamResp.Resp.GetMessages()
  
stream_receiver.go

  346
  >
  		priority := messages.Priority
  
  347
  >
  
  348
  >
  		if err := r.validateAndSetReceiverMode(priority); err != nil {
  
  349
  
  			// sender mode changed, exit loop and let stream reconnect to retry
  
  350
  
  			return NewStreamError("ReplicationTask wrong receiver mode", err)
  
  351
  
  		}
  
  352
  
  353
  >
  		if err = ValidateTasksHaveSamePriority(priority, messages.ReplicationTasks...); err != nil {
  
stream_receiver.go

  354
  
  			// This should not happen because source side is sending task 1 by 1. Validate here just in case.
  
  355
  
  			return NewStreamError("ReplicationTask priority check failed", err)
  
  356
  
  		}
  
  357
  
  358
  >
  		convertedTasks := r.taskConverter.Convert(
  
stream_receiver.go

  359
  >
  			clusterName,
  
  360
  >
  			r.clientShardKey,
  
  361
  >
  			r.serverShardKey,
  
  362
  >
  			messages.ReplicationTasks...,
  
  363
  >
  		)
  
  364
  >
  		exclusiveHighWatermark := messages.ExclusiveHighWatermark
  
  365
  >
  		exclusiveHighWatermarkTime := timestamp.TimeValue(messages.ExclusiveHighWatermarkTime)
  
  366
  >
  		taskTracker, err := r.getTaskTracker(priority)
  
  367
  >
  		if err != nil {
  
  368
  
  			// Todo: Change to write Tasks to DLQ. As resend task will not help here
  
  369
  
  			return NewStreamError("ReplicationTask wrong priority", err)
  
  370
  
  		}
  
  371
  
  372
  >
  		submissionThreshold := r.Config.ReplicationReceiverSlowSubmissionLatencyThreshold()
  
stream_receiver.go

  373
  >
  
  374
  >
  		for _, task := range taskTracker.TrackTasks(WatermarkInfo{
  
  375
  >
  			Watermark: exclusiveHighWatermark,
  
  376
  >
  			Timestamp: exclusiveHighWatermarkTime,
  
  377
  >
  		}, convertedTasks...) {
  
  378
  >
  			schedulerPriority, err := r.getTaskSchedulerPriority(priority, task)
  
stream_receiver.go

  379
  >
  			if err != nil {
  
  380
  
  				return err
  
  381
  
  			}
  
  382
  >
  			scheduler, err := r.getTaskScheduler(schedulerPriority)
  
stream_receiver.go

  383
  >
  			if err != nil {
  
  384
  
  				return err
  
  385
  
  			}
  
  386
  
  387
  
  			// Tests use this hook to pause replication tasks before they are applied.
  
  388
  >
  			if hook, ok := testhooks.Get(r.TestHooks, testhooks.HistoryReplicationTaskInterceptor, testhooks.GlobalScope); ok {
  
stream_receiver.go

  389
  
  				originalTask := task
  
  390
  
  				task = executeInterceptedTask{

  396
  
  			}
  
  397
  
  398
  >
  			start := time.Now()
  
stream_receiver.go

  399
  >
  			scheduler.Submit(task)
  
  400
  >
  			end := time.Now()
  
  401
  >
  			if end.Sub(start) > submissionThreshold {
  
  402
  
  				r.recordSlowSubmission(schedulerPriority, end)
  
  403
  
  			}
  
  404
  
  		}
  
  405
  
  	}
  
  406
  >
  	return nil
  
stream_receiver.go

  407
  
  }
  
  408

  422
  
  }
  
  423
  
  424
  >
  func (r *StreamReceiverImpl) getTaskTracker(priority enumsspb.TaskPriority) (ExecutableTaskTracker, error) {
  
stream_receiver.go

  425
  >
  	switch priority {
  
  426
  >
  	case enumsspb.TASK_PRIORITY_UNSPECIFIED, enumsspb.TASK_PRIORITY_HIGH:
  
  427
  >
  		return r.highPriorityTaskTracker, nil
  
  428
  
  	case enumsspb.TASK_PRIORITY_LOW:
  
  429
  
  		return r.lowPriorityTaskTracker, nil

  433
  
  }
  
  434
  
  435
  >
  func (r *StreamReceiverImpl) getTaskSchedulerPriority(priority enumsspb.TaskPriority, task TrackableExecutableTask) (enumsspb.TaskPriority, error) {
  
stream_receiver.go

  436
  >
  	switch priority {
  
  437
  >
  	case enumsspb.TASK_PRIORITY_UNSPECIFIED:
  
stream_receiver.go

  438
  >
  		switch task.(type) {
  
  439
  
  		case *ExecutableWorkflowStateTask:
  
  440
  
  			// This is an optimization for workflow state task. The low priority task scheduler is grouping task by workflow ID.

  443
  
  			return enumsspb.TASK_PRIORITY_LOW, nil
  
  444
  
  		}
  
  445
  >
  		return enumsspb.TASK_PRIORITY_HIGH, nil
  
stream_receiver.go

  446
  
  	case enumsspb.TASK_PRIORITY_HIGH, enumsspb.TASK_PRIORITY_LOW:
  
  447
  
  		return priority, nil

  451
  
  }
  
  452
  
  453
  >
  func (r *StreamReceiverImpl) getTaskScheduler(priority enumsspb.TaskPriority) (ctasks.Scheduler[TrackableExecutableTask], error) {
  
stream_receiver.go

  454
  >
  	switch priority {
  
  455
  >
  	case enumsspb.TASK_PRIORITY_HIGH:
  
  456
  >
  		return r.HighPriorityTaskScheduler, nil
  
  457
  
  	case enumsspb.TASK_PRIORITY_LOW:
  
  458
  
  		return r.LowPriorityTaskScheduler, nil

  465
  
  // If the first task is prioritized, receiver mode will be set to ReceiverModeTieredStack. If the first task is not prioritized, receiver mode will be set to ReceiverModeSingleStack.
  
  466
  
  // Receiver mode cannot be changed once it is set. If we enabled sender side to send tasks with different priority, we need to change the receiver mode by reconnecting the stream.
  
  467
  >
  func (r *StreamReceiverImpl) validateAndSetReceiverMode(priority enumsspb.TaskPriority) error {
  
stream_receiver.go

  468
  >
  	receiverMode := ReceiverMode(atomic.LoadInt32((*int32)(&r.receiverMode)))
  
  469
  >
  	switch receiverMode {
  
  470
  >
  	case ReceiverModeUnset:
  
stream_receiver.go

  471
  >
  		r.setReceiverMode(priority)
  
  472
  >
  		return nil
  
  473
  
  	case ReceiverModeSingleStack:
  
  474
  
  		if priority != enumsspb.TASK_PRIORITY_UNSPECIFIED {

  483
  
  }
  
  484
  
  485
  >
  func (r *StreamReceiverImpl) setReceiverMode(priority enumsspb.TaskPriority) {
  
stream_receiver.go

  486
  >
  	if r.receiverMode != ReceiverModeUnset {
  
  487
  
  		return
  
  488
  
  	}
  
  489
  >
  	switch priority {
  
stream_receiver.go

  490
  >
  	case enumsspb.TASK_PRIORITY_UNSPECIFIED:
  
stream_receiver.go

  491
  >
  		atomic.StoreInt32((*int32)(&r.receiverMode), int32(ReceiverModeSingleStack))
  
  492
  
  	case enumsspb.TASK_PRIORITY_HIGH, enumsspb.TASK_PRIORITY_LOW:
  
  493
  
  		atomic.StoreInt32((*int32)(&r.receiverMode), int32(ReceiverModeTieredStack))

  495
  
  }
  
  496
  
  497
  >
  func ValidateTasksHaveSamePriority(messageBatchPriority enumsspb.TaskPriority, tasks ...*replicationspb.ReplicationTask) error {
  
stream_receiver.go

  498
  >
  	if len(tasks) == 0 || messageBatchPriority == enumsspb.TASK_PRIORITY_UNSPECIFIED {
  
  499
  >
  		return nil
  
stream_receiver.go

  500
  >
  	}
  
  501
  
  	for _, task := range tasks {
  
  502
  
  		if task.Priority != messageBatchPriority {

  511
  
  	clientShardKey ClusterShardKey,
  
  512
  
  	serverShardKey ClusterShardKey,
  
  513
  >
  ) Stream {
  
stream_receiver.go

  514
  >
  	var clientProvider BiDirectionStreamClientProvider[*adminservice.StreamWorkflowReplicationMessagesRequest, *adminservice.StreamWorkflowReplicationMessagesResponse] = &streamClientProvider{
  
  515
  >
  		processToolBox: processToolBox,
  
  516
  >
  		clientShardKey: clientShardKey,
  
  517
  >
  		serverShardKey: serverShardKey,
  
  518
  >
  	}
  
  519
  >
  	return NewBiDirectionStream(
  
  520
  >
  		clientProvider,
  
  521
  >
  		processToolBox.MetricsHandler,
  
  522
  >
  		log.With(processToolBox.Logger, tag.ShardID(clientShardKey.ShardID)),
  
  523
  >
  	)
  
  524
  >
  }
  
  525
  
  526
  
  type streamClientProvider struct {

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

  152
  
  }
  
  153
  
  154
  >
  func (l *zapLogger) Error(msg string, tags ...tag.Tag) {
  
zap_logger.go

  155
  >
  	if l.zl.Core().Enabled(zap.ErrorLevel) {
  
  156
  >
  		msg = setDefaultMsg(msg)
  
  157
  >
  		fields := l.buildFieldsWithCallAt(tags)
  
  158
  >
  		l.zl.Error(msg, fields...)
  
  159
  >
  	}
  
  160
  
  }
  
  161

  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/executions.pb.go 96 covered LOC · 19 ranges

Open complete file

  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))
  
  399
  
  		if ms.LoadMessageInfo() == nil {

  402
  
  		return ms
  
  403
  
  	}
  
  404
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  405
  
  }
  
  406

  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))
  
  1469
  
  		if ms.LoadMessageInfo() == nil {

  1472
  
  		return ms
  
  1473
  
  	}
  
  1474
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  1475
  
  }
  
  1476

  1844
  
  func (*ReplicationTaskInfo) ProtoMessage() {}
  
  1845
  
  1846
  >
  func (x *ReplicationTaskInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  1847
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[9]
  
  1848
  >
  	if x != nil {
  
  1849
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1850
  
  		if ms.LoadMessageInfo() == nil {

  1853
  
  		return ms
  
  1854
  
  	}
  
  1855
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  1856
  
  }
  
  1857

  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))
  
  2895
  
  		if ms.LoadMessageInfo() == nil {

  2898
  
  		return ms
  
  2899
  
  	}
  
  2900
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  2901
  
  }
  
  2902

  3310
  
  func (*TimerInfo) ProtoMessage() {}
  
  3311
  
  3312
  >
  func (x *TimerInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  3313
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[18]
  
  3314
  >
  	if x != nil {
  
  3315
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  3316
  
  		if ms.LoadMessageInfo() == nil {

  3319
  
  		return ms
  
  3320
  
  	}
  
  3321
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  3322
  
  }
  
  3323

  3403
  
  func (*ChildExecutionInfo) ProtoMessage() {}
  
  3404
  
  3405
  >
  func (x *ChildExecutionInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  3406
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[19]
  
  3407
  >
  	if x != nil {
  
  3408
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  3409
  
  		if ms.LoadMessageInfo() == nil {

  3412
  
  		return ms
  
  3413
  
  	}
  
  3414
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  3415
  
  }
  
  3416

  3543
  
  func (*RequestCancelInfo) ProtoMessage() {}
  
  3544
  
  3545
  >
  func (x *RequestCancelInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  3546
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[20]
  
  3547
  >
  	if x != nil {
  
  3548
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  3549
  
  		if ms.LoadMessageInfo() == nil {

  3552
  
  		return ms
  
  3553
  
  	}
  
  3554
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  3555
  
  }
  
  3556

  3620
  
  func (*SignalInfo) ProtoMessage() {}
  
  3621
  
  3622
  >
  func (x *SignalInfo) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  3623
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[21]
  
  3624
  >
  	if x != nil {
  
  3625
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  3626
  
  		if ms.LoadMessageInfo() == nil {

  3629
  
  		return ms
  
  3630
  
  	}
  
  3631
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  3632
  
  }
  
  3633

  3695
  
  func (*Checksum) ProtoMessage() {}
  
  3696
  
  3697
  >
  func (x *Checksum) ProtoReflect() protoreflect.Message {
  
executions.pb.go

  3698
  >
  	mi := &file_temporal_server_api_persistence_v1_executions_proto_msgTypes[22]
  
  3699
  >
  	if x != nil {
  
  3700
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  3701
  
  		if ms.LoadMessageInfo() == nil {

  3704
  
  		return ms
  
  3705
  
  	}
  
  3706
  >
  	return mi.MessageOf(x)
  
executions.pb.go

  3707
  
  }
  
  3708

  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/api/replication/v1/message.pb.go 94 covered LOC · 28 ranges

Open complete file

  68
  
  }
  
  69
  
  70
  >
  func (x *ReplicationTask) String() string {
  
message.pb.go

  71
  >
  	return protoimpl.X.MessageStringOf(x)
  
  72
  >
  }
  
  73
  
  74
  
  func (*ReplicationTask) ProtoMessage() {}
  
  75
  
  76
  >
  func (x *ReplicationTask) ProtoReflect() protoreflect.Message {
  
message.pb.go

  77
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[0]
  
  78
  >
  	if x != nil {
  
  79
  >
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
message.pb.go

  80
  >
  		if ms.LoadMessageInfo() == nil {
  
  81
  >
  			ms.StoreMessageInfo(mi)
  
  82
  >
  		}
  
  83
  >
  		return ms
  
  84
  
  	}
  
  85
  
  	return mi.MessageOf(x)

  91
  
  }
  
  92
  
  93
  >
  func (x *ReplicationTask) GetTaskType() v1.ReplicationTaskType {
  
message.pb.go

  94
  >
  	if x != nil {
  
  95
  >
  		return x.TaskType
  
  96
  >
  	}
  
  97
  
  	return v1.ReplicationTaskType(0)
  
  98
  
  }

  216
  
  }
  
  217
  
  218
  >
  func (x *ReplicationTask) GetPriority() v1.TaskPriority {
  
message.pb.go

  219
  >
  	if x != nil {
  
  220
  
  		return x.Priority
  
  221
  
  	}
  
  222
  >
  	return v1.TaskPriority(0)
  
message.pb.go

  223
  
  }
  
  224

  830
  
  func (*NamespaceTaskAttributes) ProtoMessage() {}
  
  831
  
  832
  >
  func (x *NamespaceTaskAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  833
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[8]
  
  834
  >
  	if x != nil {
  
  835
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  836
  
  		if ms.LoadMessageInfo() == nil {

  839
  
  		return ms
  
  840
  
  	}
  
  841
  >
  	return mi.MessageOf(x)
  
message.pb.go

  842
  
  }
  
  843

  925
  
  func (*SyncShardStatusTaskAttributes) ProtoMessage() {}
  
  926
  
  927
  >
  func (x *SyncShardStatusTaskAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  928
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[9]
  
  929
  >
  	if x != nil {
  
  930
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  931
  
  		if ms.LoadMessageInfo() == nil {

  934
  
  		return ms
  
  935
  
  	}
  
  936
  >
  	return mi.MessageOf(x)
  
message.pb.go

  937
  
  }
  
  938

  1016
  
  func (*SyncActivityTaskAttributes) ProtoMessage() {}
  
  1017
  
  1018
  >
  func (x *SyncActivityTaskAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  1019
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[10]
  
  1020
  >
  	if x != nil {
  
  1021
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1022
  
  		if ms.LoadMessageInfo() == nil {

  1025
  
  		return ms
  
  1026
  
  	}
  
  1027
  >
  	return mi.MessageOf(x)
  
message.pb.go

  1028
  
  }
  
  1029

  1245
  
  func (*HistoryTaskAttributes) ProtoMessage() {}
  
  1246
  
  1247
  >
  func (x *HistoryTaskAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  1248
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[11]
  
  1249
  >
  	if x != nil {
  
  1250
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1251
  
  		if ms.LoadMessageInfo() == nil {

  1254
  
  		return ms
  
  1255
  
  	}
  
  1256
  >
  	return mi.MessageOf(x)
  
message.pb.go

  1257
  
  }
  
  1258

  1347
  
  func (*SyncWorkflowStateTaskAttributes) ProtoMessage() {}
  
  1348
  
  1349
  >
  func (x *SyncWorkflowStateTaskAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  1350
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[12]
  
  1351
  >
  	if x != nil {
  
  1352
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1353
  
  		if ms.LoadMessageInfo() == nil {

  1356
  
  		return ms
  
  1357
  
  	}
  
  1358
  >
  	return mi.MessageOf(x)
  
message.pb.go

  1359
  
  }
  
  1360

  1407
  
  func (*TaskQueueUserDataAttributes) ProtoMessage() {}
  
  1408
  
  1409
  >
  func (x *TaskQueueUserDataAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  1410
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[13]
  
  1411
  >
  	if x != nil {
  
  1412
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1413
  
  		if ms.LoadMessageInfo() == nil {

  1416
  
  		return ms
  
  1417
  
  	}
  
  1418
  >
  	return mi.MessageOf(x)
  
message.pb.go

  1419
  
  }
  
  1420

  1469
  
  func (*SyncHSMAttributes) ProtoMessage() {}
  
  1470
  
  1471
  >
  func (x *SyncHSMAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  1472
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[14]
  
  1473
  >
  	if x != nil {
  
  1474
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1475
  
  		if ms.LoadMessageInfo() == nil {

  1478
  
  		return ms
  
  1479
  
  	}
  
  1480
  >
  	return mi.MessageOf(x)
  
message.pb.go

  1481
  
  }
  
  1482

  1546
  
  func (*BackfillHistoryTaskAttributes) ProtoMessage() {}
  
  1547
  
  1548
  >
  func (x *BackfillHistoryTaskAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  1549
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[15]
  
  1550
  >
  	if x != nil {
  
  1551
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1552
  
  		if ms.LoadMessageInfo() == nil {

  1555
  
  		return ms
  
  1556
  
  	}
  
  1557
  >
  	return mi.MessageOf(x)
  
message.pb.go

  1558
  
  }
  
  1559

  1780
  
  func (*VerifyVersionedTransitionTaskAttributes) ProtoMessage() {}
  
  1781
  
  1782
  >
  func (x *VerifyVersionedTransitionTaskAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  1783
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[19]
  
  1784
  >
  	if x != nil {
  
  1785
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1786
  
  		if ms.LoadMessageInfo() == nil {

  1789
  
  		return ms
  
  1790
  
  	}
  
  1791
  >
  	return mi.MessageOf(x)
  
message.pb.go

  1792
  
  }
  
  1793

  1871
  
  func (*SyncVersionedTransitionTaskAttributes) ProtoMessage() {}
  
  1872
  
  1873
  >
  func (x *SyncVersionedTransitionTaskAttributes) ProtoReflect() protoreflect.Message {
  
message.pb.go

  1874
  >
  	mi := &file_temporal_server_api_replication_v1_message_proto_msgTypes[20]
  
  1875
  >
  	if x != nil {
  
  1876
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  1877
  
  		if ms.LoadMessageInfo() == nil {

  1880
  
  		return ms
  
  1881
  
  	}
  
  1882
  >
  	return mi.MessageOf(x)
  
message.pb.go

  1883
  
  }
  
  1884

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

Open complete file

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  239
  
  }
  
  240
  
  241
  >
  func newSearchAttributeBoolByField(field string) SearchAttributeBool {
  
search_attribute.go

  242
  >
  	return SearchAttributeBool{
  
  243
  >
  		searchAttributeDefinition: searchAttributeDefinition{
  
  244
  >
  			alias:     field,
  
  245
  >
  			field:     field,
  
  246
  >
  			valueType: enumspb.INDEXED_VALUE_TYPE_BOOL,
  
  247
  >
  		},
  
  248
  >
  	}
  
  249
  >
  }
  
  250
  
  251
  
  // Value sets the boolean value of the search attribute.

  276
  
  }
  
  277
  
  278
  >
  func newSearchAttributeDateTimeByField(field string) SearchAttributeDateTime {
  
search_attribute.go

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

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

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

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

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

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

go.temporal.io/server/api/persistence/v1/predicates.pb.go 82 covered LOC · 22 ranges

Open complete file

  57
  
  func (*Predicate) ProtoMessage() {}
  
  58
  
  59
  >
  func (x *Predicate) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  60
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[0]
  
  61
  >
  	if x != nil {
  
  62
  >
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  63
  >
  		if ms.LoadMessageInfo() == nil {
  
  64
  >
  			ms.StoreMessageInfo(mi)
  
  65
  >
  		}
  
  66
  >
  		return ms
  
  67
  
  	}
  
  68
  
  	return mi.MessageOf(x)

  261
  
  func (*UniversalPredicateAttributes) ProtoMessage() {}
  
  262
  
  263
  >
  func (x *UniversalPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  264
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[1]
  
  265
  >
  	if x != nil {
  
  266
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  267
  
  		if ms.LoadMessageInfo() == nil {

  270
  
  		return ms
  
  271
  
  	}
  
  272
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  273
  
  }
  
  274

  297
  
  func (*EmptyPredicateAttributes) ProtoMessage() {}
  
  298
  
  299
  >
  func (x *EmptyPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  300
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[2]
  
  301
  >
  	if x != nil {
  
  302
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  303
  
  		if ms.LoadMessageInfo() == nil {

  306
  
  		return ms
  
  307
  
  	}
  
  308
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  309
  
  }
  
  310

  334
  
  func (*AndPredicateAttributes) ProtoMessage() {}
  
  335
  
  336
  >
  func (x *AndPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  337
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[3]
  
  338
  >
  	if x != nil {
  
  339
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  340
  
  		if ms.LoadMessageInfo() == nil {

  343
  
  		return ms
  
  344
  
  	}
  
  345
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  346
  
  }
  
  347

  378
  
  func (*OrPredicateAttributes) ProtoMessage() {}
  
  379
  
  380
  >
  func (x *OrPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  381
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[4]
  
  382
  >
  	if x != nil {
  
  383
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  384
  
  		if ms.LoadMessageInfo() == nil {

  387
  
  		return ms
  
  388
  
  	}
  
  389
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  390
  
  }
  
  391

  422
  
  func (*NotPredicateAttributes) ProtoMessage() {}
  
  423
  
  424
  >
  func (x *NotPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  425
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[5]
  
  426
  >
  	if x != nil {
  
  427
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  428
  
  		if ms.LoadMessageInfo() == nil {

  431
  
  		return ms
  
  432
  
  	}
  
  433
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  434
  
  }
  
  435

  466
  
  func (*NamespaceIdPredicateAttributes) ProtoMessage() {}
  
  467
  
  468
  >
  func (x *NamespaceIdPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

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

  475
  
  		return ms
  
  476
  
  	}
  
  477
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  478
  
  }
  
  479

  510
  
  func (*TaskTypePredicateAttributes) ProtoMessage() {}
  
  511
  
  512
  >
  func (x *TaskTypePredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  513
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[7]
  
  514
  >
  	if x != nil {
  
  515
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  516
  
  		if ms.LoadMessageInfo() == nil {

  519
  
  		return ms
  
  520
  
  	}
  
  521
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  522
  
  }
  
  523

  554
  
  func (*DestinationPredicateAttributes) ProtoMessage() {}
  
  555
  
  556
  >
  func (x *DestinationPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  557
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[8]
  
  558
  >
  	if x != nil {
  
  559
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  560
  
  		if ms.LoadMessageInfo() == nil {

  563
  
  		return ms
  
  564
  
  	}
  
  565
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  566
  
  }
  
  567

  598
  
  func (*OutboundTaskGroupPredicateAttributes) ProtoMessage() {}
  
  599
  
  600
  >
  func (x *OutboundTaskGroupPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  601
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[9]
  
  602
  >
  	if x != nil {
  
  603
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  604
  
  		if ms.LoadMessageInfo() == nil {

  607
  
  		return ms
  
  608
  
  	}
  
  609
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  610
  
  }
  
  611

  642
  
  func (*OutboundTaskPredicateAttributes) ProtoMessage() {}
  
  643
  
  644
  >
  func (x *OutboundTaskPredicateAttributes) ProtoReflect() protoreflect.Message {
  
predicates.pb.go

  645
  >
  	mi := &file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[10]
  
  646
  >
  	if x != nil {
  
  647
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  648
  
  		if ms.LoadMessageInfo() == nil {

  651
  
  		return ms
  
  652
  
  	}
  
  653
  >
  	return mi.MessageOf(x)
  
predicates.pb.go

  654
  
  }
  
  655

  828
  
  }
  
  829
  
  830
  >
  func init() { file_temporal_server_api_persistence_v1_predicates_proto_init() }
  
predicates.pb.go

  831
  >
  func file_temporal_server_api_persistence_v1_predicates_proto_init() {
  
  832
  >
  	if File_temporal_server_api_persistence_v1_predicates_proto != nil {
  
  833
  >
  		return
  
  834
  >
  	}
  
  835
  >
  	file_temporal_server_api_persistence_v1_predicates_proto_msgTypes[0].OneofWrappers = []any{
  
  836
  >
  		(*Predicate_UniversalPredicateAttributes)(nil),
  
  837
  >
  		(*Predicate_EmptyPredicateAttributes)(nil),
  
  838
  >
  		(*Predicate_AndPredicateAttributes)(nil),
  
  839
  >
  		(*Predicate_OrPredicateAttributes)(nil),
  
  840
  >
  		(*Predicate_NotPredicateAttributes)(nil),
  
  841
  >
  		(*Predicate_NamespaceIdPredicateAttributes)(nil),
  
  842
  >
  		(*Predicate_TaskTypePredicateAttributes)(nil),
  
  843
  >
  		(*Predicate_DestinationPredicateAttributes)(nil),
  
  844
  >
  		(*Predicate_OutboundTaskGroupPredicateAttributes)(nil),
  
  845
  >
  		(*Predicate_OutboundTaskPredicateAttributes)(nil),
  
  846
  >
  	}
  
  847
  >
  	type x struct{}
  
  848
  >
  	out := protoimpl.TypeBuilder{
  
  849
  >
  		File: protoimpl.DescBuilder{
  
  850
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  851
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_predicates_proto_rawDesc), len(file_temporal_server_api_persistence_v1_predicates_proto_rawDesc)),
  
  852
  >
  			NumEnums:      0,
  
  853
  >
  			NumMessages:   12,
  
  854
  >
  			NumExtensions: 0,
  
  855
  >
  			NumServices:   0,
  
  856
  >
  		},
  
  857
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_predicates_proto_goTypes,
  
  858
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_predicates_proto_depIdxs,
  
  859
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_predicates_proto_msgTypes,
  
  860
  >
  	}.Build()
  
  861
  >
  	File_temporal_server_api_persistence_v1_predicates_proto = out.File
  
  862
  >
  	file_temporal_server_api_persistence_v1_predicates_proto_goTypes = nil
  
  863
  >
  	file_temporal_server_api_persistence_v1_predicates_proto_depIdxs = nil
  
  864
  
  }

go.temporal.io/server/api/persistence/v1/hsm.pb.go 64 covered LOC · 17 ranges

Open complete file

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

  74
  >
  	mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[0]
  
  75
  >
  	if x != nil {
  
  76
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  77
  
  		if ms.LoadMessageInfo() == nil {

  80
  
  		return ms
  
  81
  
  	}
  
  82
  >
  	return mi.MessageOf(x)
  
hsm.pb.go

  83
  
  }
  
  84

  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

  763
  
  func (*StateMachinePath) ProtoMessage() {}
  
  764
  
  765
  >
  func (x *StateMachinePath) ProtoReflect() protoreflect.Message {
  
hsm.pb.go

  766
  >
  	mi := &file_temporal_server_api_persistence_v1_hsm_proto_msgTypes[9]
  
  767
  >
  	if x != nil {
  
  768
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  769
  
  		if ms.LoadMessageInfo() == nil {

  772
  
  		return ms
  
  773
  
  	}
  
  774
  >
  	return mi.MessageOf(x)
  
hsm.pb.go

  775
  
  }
  
  776

  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/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/api/adminservice/v1/request_response.pb.go 41 covered LOC · 2 ranges

Open complete file

  3786
  
  }
  
  3787
  
  3788
  >
  func (x *StreamWorkflowReplicationMessagesResponse) GetMessages() *v15.WorkflowReplicationMessages {
  
request_response.pb.go

  3789
  >
  	if x != nil {
  
  3790
  >
  		if x, ok := x.Attributes.(*StreamWorkflowReplicationMessagesResponse_Messages); ok {
  
  3791
  >
  			return x.Messages
  
  3792
  >
  		}
  
  3793
  
  	}
  
  3794
  
  	return nil

  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/persistence/v1/chasm.pb.go 41 covered LOC · 5 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))
  
  56
  
  		if ms.LoadMessageInfo() == nil {

  59
  
  		return ms
  
  60
  
  	}
  
  61
  >
  	return mi.MessageOf(x)
  
chasm.pb.go

  62
  
  }
  
  63

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

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

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

  583
  
  }
  
  584

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

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

go.temporal.io/server/common/log/tag/tags.go 39 covered LOC · 13 ranges

Open complete file

  30
  
  31
  
  // Operation returns tag for Operation
  
  32
  >
  func Operation(operation string) ZapTag {
  
tags.go

  33
  >
  	return NewStringTag("operation", operation)
  
  34
  >
  }
  
  35
  
  36
  
  // Error returns tag for Error

  70
  
  71
  
  // WorkflowAction returns tag for WorkflowAction
  
  72
  >
  func workflowAction(action string) ZapTag {
  
tags.go

  73
  >
  	return NewStringTag("wf-action", action)
  
  74
  >
  }
  
  75
  
  76
  
  // WorkflowListFilterType returns tag for WorkflowListFilterType
  
  77
  >
  func workflowListFilterType(listFilterType string) ZapTag {
  
tags.go

  78
  >
  	return NewStringTag("wf-list-filter-type", listFilterType)
  
  79
  >
  }
  
  80
  
  81
  
  // general

  376
  
  377
  
  // Component returns tag for Component
  
  378
  >
  func component(component string) ZapTag {
  
tags.go

  379
  >
  	return NewStringTag("component", component)
  
  380
  >
  }
  
  381
  
  382
  
  // Lifecycle returns tag for Lifecycle
  
  383
  >
  func lifecycle(lifecycle string) ZapTag {
  
tags.go

  384
  >
  	return NewStringTag("lifecycle", lifecycle)
  
  385
  >
  }
  
  386
  
  387
  
  // StoreOperation returns tag for StoreOperation
  
  388
  >
  func storeOperation(storeOperation string) ZapTag {
  
tags.go

  389
  >
  	return NewStringTag("store-operation", storeOperation)
  
  390
  >
  }
  
  391
  
  392
  
  // OperationResult returns tag for OperationResult
  
  393
  >
  func operationResult(operationResult string) ZapTag {
  
tags.go

  394
  >
  	return NewStringTag("operation-result", operationResult)
  
  395
  >
  }
  
  396
  
  397
  
  // ErrorType returns tag for ErrorType

  401
  
  402
  
  // errorType returns tag for ErrorType given a string
  
  403
  >
  func errorType(errorType string) ZapTag {
  
tags.go

  404
  >
  	return NewStringTag("error-type", errorType)
  
  405
  >
  }
  
  406
  
  407
  
  // Shardupdate returns tag for Shardupdate
  
  408
  >
  func shardupdate(shardupdate string) ZapTag {
  
tags.go

  409
  >
  	return NewStringTag("shard-update", shardupdate)
  
  410
  >
  }
  
  411
  
  412
  
  // scope returns a tag for scope
  
  413
  
  // Pre-defined scope tags are in values.go.
  
  414
  >
  func scope(scope string) ZapTag {
  
tags.go

  415
  >
  	return NewStringTag("scope", scope)
  
  416
  >
  }
  
  417
  
  418
  
  // general

  553
  
  554
  
  // ShardID returns tag for ShardID
  
  555
  >
  func ShardID(shardID int32) ZapTag {
  
tags.go

  556
  >
  	return NewInt32("shard-id", shardID)
  
  557
  >
  }
  
  558
  
  559
  
  // ShardTime returns tag for ShardTime

  775
  
  776
  
  // SourceCluster returns tag for SourceCluster
  
  777
  >
  func SourceCluster(sourceCluster string) ZapTag {
  
tags.go

  778
  >
  	return NewStringTag("xdc-source-cluster", sourceCluster)
  
  779
  >
  }
  
  780
  
  781
  
  // TargetCluster returns tag for TargetCluster

  784
  
  }
  
  785
  
  786
  >
  func SourceShardID(shardID int32) ZapTag {
  
tags.go

  787
  >
  	return NewInt32("xdc-source-shard-id", shardID)
  
  788
  >
  }
  
  789
  
  790
  
  func TargetShardID(shardID int32) ZapTag {

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

Open complete file

  20
  
  )
  
  21
  
  22
  >
  func NewTimerDef(name string, opts ...Option) timerDefinition {
  
defs.go

  23
  >
  	// This line cannot be combined with others!
  
  24
  >
  	// This ensures the stack trace has information of the caller.
  
  25
  >
  	def := newMetricDefinition(name, opts...)
  
  26
  >
  	globalRegistry.register(def)
  
  27
  >
  	return timerDefinition{def}
  
  28
  >
  }
  
  29
  
  30
  >
  func NewBytesHistogramDef(name string, opts ...Option) histogramDefinition {
  
defs.go

  31
  >
  	// This line cannot be combined with others!
  
  32
  >
  	// This ensures the stack trace has information of the caller.
  
  33
  >
  	def := newMetricDefinition(name, append(opts, WithUnit(Bytes))...)
  
  34
  >
  	globalRegistry.register(def)
  
  35
  >
  	return histogramDefinition{def}
  
  36
  >
  }
  
  37
  
  38
  >
  func NewDimensionlessHistogramDef(name string, opts ...Option) histogramDefinition {
  
defs.go

  39
  >
  	// This line cannot be combined with others!
  
  40
  >
  	// This ensures the stack trace has information of the caller.
  
  41
  >
  	def := newMetricDefinition(name, append(opts, WithUnit(Dimensionless))...)
  
  42
  >
  	globalRegistry.register(def)
  
  43
  >
  	return histogramDefinition{def}
  
  44
  >
  }
  
  45
  
  46
  >
  func NewCounterDef(name string, opts ...Option) counterDefinition {
  
defs.go

  47
  >
  	// This line cannot be combined with others!
  
  48
  >
  	// This ensures the stack trace has information of the caller.
  
  49
  >
  	def := newMetricDefinition(name, opts...)
  
  50
  >
  	globalRegistry.register(def)
  
  51
  >
  	return counterDefinition{def}
  
  52
  >
  }
  
  53
  
  54
  >
  func NewGaugeDef(name string, opts ...Option) gaugeDefinition {
  
defs.go

  55
  >
  	// This line cannot be combined with others!
  
  56
  >
  	// This ensures the stack trace has information of the caller.
  
  57
  >
  	def := newMetricDefinition(name, opts...)
  
  58
  >
  	globalRegistry.register(def)
  
  59
  >
  	return gaugeDefinition{def}
  
  60
  >
  }
  
  61
  
  62
  
  func (d histogramDefinition) With(handler Handler) HistogramIface {

  64
  
  }
  
  65
  
  66
  >
  func (d counterDefinition) With(handler Handler) CounterIface {
  
defs.go

  67
  >
  	return handler.Counter(d.name)
  
  68
  >
  }
  
  69
  
  70
  
  func (d gaugeDefinition) With(handler Handler) GaugeIface {

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/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/api/persistence/v1/workflow_mutable_state.pb.go 32 covered LOC · 6 ranges

Open complete file

  55
  
  func (*WorkflowMutableState) ProtoMessage() {}
  
  56
  
  57
  >
  func (x *WorkflowMutableState) ProtoReflect() protoreflect.Message {
  
workflow_mutable_state.pb.go

  58
  >
  	mi := &file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_msgTypes[0]
  
  59
  >
  	if x != nil {
  
  60
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  61
  
  		if ms.LoadMessageInfo() == nil {

  64
  
  		return ms
  
  65
  
  	}
  
  66
  >
  	return mi.MessageOf(x)
  
workflow_mutable_state.pb.go

  67
  
  }
  
  68

  192
  
  func (*WorkflowMutableStateMutation) ProtoMessage() {}
  
  193
  
  194
  >
  func (x *WorkflowMutableStateMutation) ProtoReflect() protoreflect.Message {
  
workflow_mutable_state.pb.go

  195
  >
  	mi := &file_temporal_server_api_persistence_v1_workflow_mutable_state_proto_msgTypes[1]
  
  196
  >
  	if x != nil {
  
  197
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  198
  
  		if ms.LoadMessageInfo() == nil {

  201
  
  		return ms
  
  202
  
  	}
  
  203
  >
  	return mi.MessageOf(x)
  
workflow_mutable_state.pb.go

  204
  
  }
  
  205

  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/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/service/history/replication/executable_task_converter.go 31 covered LOC · 7 ranges

Open complete file

  27
  
  func NewExecutableTaskConverter(
  
  28
  
  	processToolBox ProcessToolBox,
  
  29
  >
  ) *executableTaskConverterImpl {
  
executable_task_converter.go

  30
  >
  	return &executableTaskConverterImpl{
  
  31
  >
  		processToolBox: processToolBox,
  
  32
  >
  	}
  
  33
  >
  }
  
  34
  
  35
  
  func (e *executableTaskConverterImpl) Convert(

  38
  
  	serverShardKey ClusterShardKey,
  
  39
  
  	replicationTasks ...*replicationspb.ReplicationTask,
  
  40
  >
  ) []TrackableExecutableTask {
  
executable_task_converter.go

  41
  >
  	tasks := make([]TrackableExecutableTask, len(replicationTasks))
  
  42
  >
  	for index, replicationTask := range replicationTasks {
  
  43
  >
  		metrics.ReplicationTasksRecv.With(e.processToolBox.MetricsHandler).Record(
  
executable_task_converter.go

  44
  >
  			int64(1),
  
  45
  >
  			metrics.FromClusterIDTag(serverShardKey.ClusterID),
  
  46
  >
  			metrics.ToClusterIDTag(clientShardKey.ClusterID),
  
  47
  >
  			metrics.OperationTag(TaskOperationTag(replicationTask)),
  
  48
  >
  		)
  
  49
  >
  		tasks[index] = e.convertOne(sourceClusterName, serverShardKey, replicationTask)
  
  50
  >
  	}
  
  51
  >
  	return tasks
  
executable_task_converter.go

  52
  
  }
  
  53

  56
  
  	sourceShardKey ClusterShardKey,
  
  57
  
  	replicationTask *replicationspb.ReplicationTask,
  
  58
  >
  ) TrackableExecutableTask {
  
executable_task_converter.go

  59
  >
  	var taskCreationTime time.Time
  
  60
  >
  	if replicationTask.VisibilityTime != nil {
  
  61
  >
  		taskCreationTime = replicationTask.VisibilityTime.AsTime()
  
  62
  >
  	} else {
  
  63
  
  		taskCreationTime = time.Now().UTC()
  
  64
  
  	}
  
  65
  
  66
  >
  	switch replicationTask.GetTaskType() {
  
executable_task_converter.go

  67
  
  	case enumsspb.REPLICATION_TASK_TYPE_SYNC_SHARD_STATUS_TASK: // TODO to be deprecated
  
  68
  
  		return NewExecutableNoopTask(

  157
  
  			replicationTask,
  
  158
  
  		)
  
  159
  >
  	default:
  
executable_task_converter.go

  160
  >
  		e.processToolBox.Logger.Error(fmt.Sprintf("unknown replication task: %v", replicationTask))
  
  161
  >
  		return NewExecutableUnknownTask(
  
  162
  >
  			e.processToolBox,
  
  163
  >
  			replicationTask.SourceTaskId,
  
  164
  >
  			taskCreationTime,
  
  165
  >
  			replicationTask,
  
  166
  >
  		)
  
  167
  
  	}
  
  168
  
  }

go.temporal.io/server/common/persistence/sql/sqlplugin/mysql/execution_maps.go 30 covered LOC · 5 ranges

Open complete file

  53
  
  )
  
  54
  
  55
  >
  func stringMap(a []string, f func(string) string) []string {
  
execution_maps.go

  56
  >
  	b := make([]string, len(a))
  
  57
  >
  	for i, v := range a {
  
  58
  >
  		b[i] = f(v)
  
  59
  >
  	}
  
  60
  >
  	return b
  
  61
  
  }
  
  62
  
  63
  >
  func makeDeleteMapQry(tableName string) string {
  
execution_maps.go

  64
  >
  	return fmt.Sprintf(deleteMapQryTemplate, tableName)
  
  65
  >
  }
  
  66
  
  67
  >
  func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  68
  >
  	return fmt.Sprintf(setKeyInMapQryTemplate,
  
  69
  >
  		tableName,
  
  70
  >
  		strings.Join(nonPrimaryKeyColumns, ","),
  
  71
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  72
  >
  			return ":" + x
  
  73
  >
  		}), ","),
  
  74
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  75
  >
  			return x + "=VALUES(" + x + ")"
  
  76
  >
  		}), ","),
  
  77
  
  		mapKeyName)
  
  78
  
  }
  
  79
  
  80
  >
  func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string {
  
execution_maps.go

  81
  >
  	return fmt.Sprintf(deleteKeyInMapQryTemplate,
  
  82
  >
  		tableName,
  
  83
  >
  		mapKeyName)
  
  84
  >
  }
  
  85
  
  86
  >
  func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  87
  >
  	return fmt.Sprintf(getMapQryTemplate,
  
  88
  >
  		tableName,
  
  89
  >
  		mapKeyName,
  
  90
  >
  		strings.Join(nonPrimaryKeyColumns, ","))
  
  91
  >
  }
  
  92
  
  93
  
  var (

go.temporal.io/server/common/persistence/sql/sqlplugin/postgresql/execution_maps.go 30 covered LOC · 6 ranges

Open complete file

  86
  
  )
  
  87
  
  88
  >
  func stringMap(a []string, f func(string) string) []string {
  
execution_maps.go

  89
  >
  	b := make([]string, len(a))
  
  90
  >
  	for i, v := range a {
  
  91
  >
  		b[i] = f(v)
  
  92
  >
  	}
  
  93
  >
  	return b
  
  94
  
  }
  
  95
  
  96
  >
  func makeDeleteMapQry(tableName string) string {
  
execution_maps.go

  97
  >
  	return fmt.Sprintf(deleteMapQueryTemplate, tableName)
  
  98
  >
  }
  
  99
  
  100
  >
  func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  101
  >
  	return fmt.Sprintf(setKeyInMapQueryTemplate,
  
  102
  >
  		tableName,
  
  103
  >
  		strings.Join(nonPrimaryKeyColumns, ","),
  
  104
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  105
  >
  			return ":" + x
  
  106
  >
  		}), ","),
  
  107
  
  		mapKeyName,
  
  108
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
execution_maps.go

  109
  >
  			return "excluded." + x
  
  110
  >
  		}), ","))
  
  111
  
  }
  
  112
  
  113
  >
  func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string {
  
execution_maps.go

  114
  >
  	return fmt.Sprintf(deleteKeyInMapQueryTemplate,
  
  115
  >
  		tableName,
  
  116
  >
  		mapKeyName)
  
  117
  >
  }
  
  118
  
  119
  >
  func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  120
  >
  	return fmt.Sprintf(getMapQueryTemplate,
  
  121
  >
  		tableName,
  
  122
  >
  		mapKeyName,
  
  123
  >
  		strings.Join(nonPrimaryKeyColumns, ","))
  
  124
  >
  }
  
  125
  
  126
  
  var (

go.temporal.io/server/common/persistence/sql/sqlplugin/sqlite/execution_maps.go 30 covered LOC · 5 ranges

Open complete file

  52
  
  )
  
  53
  
  54
  >
  func stringMap(a []string, f func(string) string) []string {
  
execution_maps.go

  55
  >
  	b := make([]string, len(a))
  
  56
  >
  	for i, v := range a {
  
  57
  >
  		b[i] = f(v)
  
  58
  >
  	}
  
  59
  >
  	return b
  
  60
  
  }
  
  61
  
  62
  >
  func makeDeleteMapQry(tableName string) string {
  
execution_maps.go

  63
  >
  	return fmt.Sprintf(deleteMapQryTemplate, tableName)
  
  64
  >
  }
  
  65
  
  66
  >
  func makeSetKeyInMapQry(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  67
  >
  	return fmt.Sprintf(setKeyInMapQryTemplate,
  
  68
  >
  		tableName,
  
  69
  >
  		strings.Join(nonPrimaryKeyColumns, ","),
  
  70
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  71
  >
  			return ":" + x
  
  72
  >
  		}), ","),
  
  73
  >
  		strings.Join(stringMap(nonPrimaryKeyColumns, func(x string) string {
  
  74
  >
  			return x + "=" + x
  
  75
  >
  		}), ","),
  
  76
  
  		mapKeyName)
  
  77
  
  }
  
  78
  
  79
  >
  func makeDeleteKeyInMapQry(tableName string, mapKeyName string) string {
  
execution_maps.go

  80
  >
  	return fmt.Sprintf(deleteKeyInMapQryTemplate,
  
  81
  >
  		tableName,
  
  82
  >
  		mapKeyName)
  
  83
  >
  }
  
  84
  
  85
  >
  func makeGetMapQryTemplate(tableName string, nonPrimaryKeyColumns []string, mapKeyName string) string {
  
execution_maps.go

  86
  >
  	return fmt.Sprintf(getMapQryTemplate,
  
  87
  >
  		tableName,
  
  88
  >
  		mapKeyName,
  
  89
  >
  		strings.Join(nonPrimaryKeyColumns, ","))
  
  90
  >
  }
  
  91
  
  92
  
  var (

go.temporal.io/server/common/searchattribute/sadefs/constants.go 30 covered LOC · 9 ranges

Open complete file

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

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

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

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

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

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

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

  348
  >
  	}
  
  349
  
  	return name
  
  350
  
  }

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

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

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

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

go.temporal.io/server/api/enums/v1/replication.pb.go 29 covered LOC · 5 ranges

Open complete file

  125
  
  }
  
  126
  
  127
  >
  func (ReplicationTaskType) Descriptor() protoreflect.EnumDescriptor {
  
replication.pb.go

  128
  >
  	return file_temporal_server_api_enums_v1_replication_proto_enumTypes[0].Descriptor()
  
  129
  >
  }
  
  130
  
  131
  
  func (ReplicationTaskType) Type() protoreflect.EnumType {

  182
  
  }
  
  183
  
  184
  >
  func (NamespaceOperation) Descriptor() protoreflect.EnumDescriptor {
  
replication.pb.go

  185
  >
  	return file_temporal_server_api_enums_v1_replication_proto_enumTypes[1].Descriptor()
  
  186
  >
  }
  
  187
  
  188
  
  func (NamespaceOperation) Type() protoreflect.EnumType {

  241
  
  }
  
  242
  
  243
  >
  func (ReplicationFlowControlCommand) Descriptor() protoreflect.EnumDescriptor {
  
replication.pb.go

  244
  >
  	return file_temporal_server_api_enums_v1_replication_proto_enumTypes[2].Descriptor()
  
  245
  >
  }
  
  246
  
  247
  
  func (ReplicationFlowControlCommand) Type() protoreflect.EnumType {

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

  113
  
  func (*HybridLogicalClock) ProtoMessage() {}
  
  114
  
  115
  >
  func (x *HybridLogicalClock) ProtoReflect() protoreflect.Message {
  
message.pb.go

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

  122
  
  		return ms
  
  123
  
  	}
  
  124
  >
  	return mi.MessageOf(x)
  
message.pb.go

  125
  
  }
  
  126

  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/api/deployment/v1/message.pb.go 28 covered LOC · 6 ranges

Open complete file

  128
  
  func (*DeploymentVersionData) ProtoMessage() {}
  
  129
  
  130
  >
  func (x *DeploymentVersionData) ProtoReflect() protoreflect.Message {
  
message.pb.go

  131
  >
  	mi := &file_temporal_server_api_deployment_v1_message_proto_msgTypes[1]
  
  132
  >
  	if x != nil {
  
  133
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  134
  
  		if ms.LoadMessageInfo() == nil {

  137
  
  		return ms
  
  138
  
  	}
  
  139
  >
  	return mi.MessageOf(x)
  
message.pb.go

  140
  
  }
  
  141

  223
  
  func (*WorkerDeploymentVersionData) ProtoMessage() {}
  
  224
  
  225
  >
  func (x *WorkerDeploymentVersionData) ProtoReflect() protoreflect.Message {
  
message.pb.go

  226
  >
  	mi := &file_temporal_server_api_deployment_v1_message_proto_msgTypes[2]
  
  227
  >
  	if x != nil {
  
  228
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  229
  
  		if ms.LoadMessageInfo() == nil {

  232
  
  		return ms
  
  233
  
  	}
  
  234
  >
  	return mi.MessageOf(x)
  
message.pb.go

  235
  
  }
  
  236

  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/common/cluster/metadata_mock.go 28 covered LOC · 6 ranges

Open complete file

  30
  
  31
  
  // NewMockMetadata creates a new mock instance.
  
  32
  >
  func NewMockMetadata(ctrl *gomock.Controller) *MockMetadata {
  
metadata_mock.go

  33
  >
  	mock := &MockMetadata{ctrl: ctrl}
  
  34
  >
  	mock.recorder = &MockMetadataMockRecorder{mock}
  
  35
  >
  	return mock
  
  36
  >
  }
  
  37
  
  38
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  39
  >
  func (m *MockMetadata) EXPECT() *MockMetadataMockRecorder {
  
metadata_mock.go

  40
  >
  	return m.recorder
  
  41
  >
  }
  
  42
  
  43
  
  // ClusterNameForFailoverVersion mocks base method.
  
  44
  >
  func (m *MockMetadata) ClusterNameForFailoverVersion(isGlobalNamespace bool, failoverVersion int64) string {
  
metadata_mock.go

  45
  >
  	m.ctrl.T.Helper()
  
  46
  >
  	ret := m.ctrl.Call(m, "ClusterNameForFailoverVersion", isGlobalNamespace, failoverVersion)
  
  47
  >
  	ret0, _ := ret[0].(string)
  
  48
  >
  	return ret0
  
  49
  >
  }
  
  50
  
  51
  
  // ClusterNameForFailoverVersion indicates an expected call of ClusterNameForFailoverVersion.
  
  52
  >
  func (mr *MockMetadataMockRecorder) ClusterNameForFailoverVersion(isGlobalNamespace, failoverVersion any) *gomock.Call {
  
metadata_mock.go

  53
  >
  	mr.mock.ctrl.T.Helper()
  
  54
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNameForFailoverVersion", reflect.TypeOf((*MockMetadata)(nil).ClusterNameForFailoverVersion), isGlobalNamespace, failoverVersion)
  
  55
  >
  }
  
  56
  
  57
  
  // GetAllClusterInfo mocks base method.
  
  58
  >
  func (m *MockMetadata) GetAllClusterInfo() map[string]ClusterInformation {
  
metadata_mock.go

  59
  >
  	m.ctrl.T.Helper()
  
  60
  >
  	ret := m.ctrl.Call(m, "GetAllClusterInfo")
  
  61
  >
  	ret0, _ := ret[0].(map[string]ClusterInformation)
  
  62
  >
  	return ret0
  
  63
  >
  }
  
  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.

go.temporal.io/server/common/util.go 28 covered LOC · 5 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

go.temporal.io/server/api/persistence/v1/queues.pb.go 27 covered LOC · 3 ranges

Open complete file

  98
  
  func (*QueueState) ProtoMessage() {}
  
  99
  
  100
  >
  func (x *QueueState) ProtoReflect() protoreflect.Message {
  
queues.pb.go

  101
  >
  	mi := &file_temporal_server_api_persistence_v1_queues_proto_msgTypes[1]
  
  102
  >
  	if x != nil {
  
  103
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  104
  
  		if ms.LoadMessageInfo() == nil {

  107
  
  		return ms
  
  108
  
  	}
  
  109
  >
  	return mi.MessageOf(x)
  
queues.pb.go

  110
  
  }
  
  111

  616
  
  }
  
  617
  
  618
  >
  func init() { file_temporal_server_api_persistence_v1_queues_proto_init() }
  
queues.pb.go

  619
  >
  func file_temporal_server_api_persistence_v1_queues_proto_init() {
  
  620
  >
  	if File_temporal_server_api_persistence_v1_queues_proto != nil {
  
  621
  >
  		return
  
  622
  >
  	}
  
  623
  >
  	file_temporal_server_api_persistence_v1_predicates_proto_init()
  
  624
  >
  	type x struct{}
  
  625
  >
  	out := protoimpl.TypeBuilder{
  
  626
  >
  		File: protoimpl.DescBuilder{
  
  627
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  628
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_queues_proto_rawDesc), len(file_temporal_server_api_persistence_v1_queues_proto_rawDesc)),
  
  629
  >
  			NumEnums:      0,
  
  630
  >
  			NumMessages:   12,
  
  631
  >
  			NumExtensions: 0,
  
  632
  >
  			NumServices:   0,
  
  633
  >
  		},
  
  634
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_queues_proto_goTypes,
  
  635
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_queues_proto_depIdxs,
  
  636
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_queues_proto_msgTypes,
  
  637
  >
  	}.Build()
  
  638
  >
  	File_temporal_server_api_persistence_v1_queues_proto = out.File
  
  639
  >
  	file_temporal_server_api_persistence_v1_queues_proto_goTypes = nil
  
  640
  >
  	file_temporal_server_api_persistence_v1_queues_proto_depIdxs = nil
  
  641
  
  }

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

Open complete file

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

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

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

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

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

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

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

go.temporal.io/server/api/enums/v1/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/api/persistence/v1/task_queues.pb.go 25 covered LOC · 4 ranges

Open complete file

  675
  
  func (*TaskQueueUserData) ProtoMessage() {}
  
  676
  
  677
  >
  func (x *TaskQueueUserData) ProtoReflect() protoreflect.Message {
  
task_queues.pb.go

  678
  >
  	mi := &file_temporal_server_api_persistence_v1_task_queues_proto_msgTypes[8]
  
  679
  >
  	if x != nil {
  
  680
  
  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  
  681
  
  		if ms.LoadMessageInfo() == nil {

  684
  
  		return ms
  
  685
  
  	}
  
  686
  >
  	return mi.MessageOf(x)
  
task_queues.pb.go

  687
  
  }
  
  688

  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/chasm/lib/activity/gen/activitypb/v1/activity_state.pb.go 25 covered LOC · 2 ranges

Open complete file

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

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

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

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

Open complete file

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

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

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

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

Open complete file

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

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

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

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

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

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

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

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

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

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

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

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

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

Open complete file

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

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

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

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

Open complete file

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

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

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

  201
  
  }
  
  202

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

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

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

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

Open complete file

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

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

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

go.temporal.io/server/api/enums/v1/fairness_state.pb.go 23 covered LOC · 3 ranges

Open complete file

  71
  
  }
  
  72
  
  73
  >
  func (FairnessState) Descriptor() protoreflect.EnumDescriptor {
  
fairness_state.pb.go

  74
  >
  	return file_temporal_server_api_enums_v1_fairness_state_proto_enumTypes[0].Descriptor()
  
  75
  >
  }
  
  76
  
  77
  
  func (FairnessState) Type() protoreflect.EnumType {

  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/nexus.pb.go 23 covered LOC · 3 ranges

Open complete file

  102
  
  }
  
  103
  
  104
  >
  func (NexusOperationState) Descriptor() protoreflect.EnumDescriptor {
  
nexus.pb.go

  105
  >
  	return file_temporal_server_api_enums_v1_nexus_proto_enumTypes[0].Descriptor()
  
  106
  >
  }
  
  107
  
  108
  
  func (NexusOperationState) Type() protoreflect.EnumType {

  158
  
  }
  
  159
  
  160
  >
  func init() { file_temporal_server_api_enums_v1_nexus_proto_init() }
  
nexus.pb.go

  161
  >
  func file_temporal_server_api_enums_v1_nexus_proto_init() {
  
  162
  >
  	if File_temporal_server_api_enums_v1_nexus_proto != nil {
  
  163
  
  		return
  
  164
  
  	}
  
  165
  >
  	type x struct{}
  
nexus.pb.go

  166
  >
  	out := protoimpl.TypeBuilder{
  
  167
  >
  		File: protoimpl.DescBuilder{
  
  168
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  169
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_nexus_proto_rawDesc), len(file_temporal_server_api_enums_v1_nexus_proto_rawDesc)),
  
  170
  >
  			NumEnums:      1,
  
  171
  >
  			NumMessages:   0,
  
  172
  >
  			NumExtensions: 0,
  
  173
  >
  			NumServices:   0,
  
  174
  >
  		},
  
  175
  >
  		GoTypes:           file_temporal_server_api_enums_v1_nexus_proto_goTypes,
  
  176
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_nexus_proto_depIdxs,
  
  177
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_nexus_proto_enumTypes,
  
  178
  >
  	}.Build()
  
  179
  >
  	File_temporal_server_api_enums_v1_nexus_proto = out.File
  
  180
  >
  	file_temporal_server_api_enums_v1_nexus_proto_goTypes = nil
  
  181
  >
  	file_temporal_server_api_enums_v1_nexus_proto_depIdxs = nil
  
  182
  
  }

go.temporal.io/server/api/enums/v1/predicate.pb.go 23 covered LOC · 3 ranges

Open complete file

  111
  
  }
  
  112
  
  113
  >
  func (PredicateType) Descriptor() protoreflect.EnumDescriptor {
  
predicate.pb.go

  114
  >
  	return file_temporal_server_api_enums_v1_predicate_proto_enumTypes[0].Descriptor()
  
  115
  >
  }
  
  116
  
  117
  
  func (PredicateType) Type() protoreflect.EnumType {

  170
  
  }
  
  171
  
  172
  >
  func init() { file_temporal_server_api_enums_v1_predicate_proto_init() }
  
predicate.pb.go

  173
  >
  func file_temporal_server_api_enums_v1_predicate_proto_init() {
  
  174
  >
  	if File_temporal_server_api_enums_v1_predicate_proto != nil {
  
  175
  
  		return
  
  176
  
  	}
  
  177
  >
  	type x struct{}
  
predicate.pb.go

  178
  >
  	out := protoimpl.TypeBuilder{
  
  179
  >
  		File: protoimpl.DescBuilder{
  
  180
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  181
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_predicate_proto_rawDesc), len(file_temporal_server_api_enums_v1_predicate_proto_rawDesc)),
  
  182
  >
  			NumEnums:      1,
  
  183
  >
  			NumMessages:   0,
  
  184
  >
  			NumExtensions: 0,
  
  185
  >
  			NumServices:   0,
  
  186
  >
  		},
  
  187
  >
  		GoTypes:           file_temporal_server_api_enums_v1_predicate_proto_goTypes,
  
  188
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_predicate_proto_depIdxs,
  
  189
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_predicate_proto_enumTypes,
  
  190
  >
  	}.Build()
  
  191
  >
  	File_temporal_server_api_enums_v1_predicate_proto = out.File
  
  192
  >
  	file_temporal_server_api_enums_v1_predicate_proto_goTypes = nil
  
  193
  >
  	file_temporal_server_api_enums_v1_predicate_proto_depIdxs = nil
  
  194
  
  }

go.temporal.io/server/api/enums/v1/workflow_task_type.pb.go 23 covered LOC · 3 ranges

Open complete file

  72
  
  }
  
  73
  
  74
  >
  func (WorkflowTaskType) Descriptor() protoreflect.EnumDescriptor {
  
workflow_task_type.pb.go

  75
  >
  	return file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes[0].Descriptor()
  
  76
  >
  }
  
  77
  
  78
  
  func (WorkflowTaskType) Type() protoreflect.EnumType {

  124
  
  }
  
  125
  
  126
  >
  func init() { file_temporal_server_api_enums_v1_workflow_task_type_proto_init() }
  
workflow_task_type.pb.go

  127
  >
  func file_temporal_server_api_enums_v1_workflow_task_type_proto_init() {
  
  128
  >
  	if File_temporal_server_api_enums_v1_workflow_task_type_proto != nil {
  
  129
  
  		return
  
  130
  
  	}
  
  131
  >
  	type x struct{}
  
workflow_task_type.pb.go

  132
  >
  	out := protoimpl.TypeBuilder{
  
  133
  >
  		File: protoimpl.DescBuilder{
  
  134
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  135
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc)),
  
  136
  >
  			NumEnums:      1,
  
  137
  >
  			NumMessages:   0,
  
  138
  >
  			NumExtensions: 0,
  
  139
  >
  			NumServices:   0,
  
  140
  >
  		},
  
  141
  >
  		GoTypes:           file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes,
  
  142
  >
  		DependencyIndexes: file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs,
  
  143
  >
  		EnumInfos:         file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes,
  
  144
  >
  	}.Build()
  
  145
  >
  	File_temporal_server_api_enums_v1_workflow_task_type_proto = out.File
  
  146
  >
  	file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes = nil
  
  147
  >
  	file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs = nil
  
  148
  
  }

go.temporal.io/server/common/dynamicconfig/shared_structure.go 23 covered LOC · 6 ranges

Open complete file

  17
  
  )
  
  18
  
  19
  >
  func warnDefaultSharedStructure(key string, def any) {
  
shared_structure.go

  20
  >
  	if path := hasSharedStructure(reflect.ValueOf(def), "root"); path != "" {
  
  21
  
  		sharedStructureWarnings.Store(key, path)
  
  22
  
  	}
  
  23
  
  }
  
  24
  
  25
  >
  func logSharedStructureWarnings(logger log.Logger) {
  
shared_structure.go

  26
  >
  	// If you see this warning, it means that a default value used in New*TypedSetting has a
  
  27
  >
  	// non-nil slice or map in it. That can lead to confusing behavior since the value from
  
  28
  >
  	// dynamic config will be merged over the default value (e.g. the slice will be appended
  
  29
  >
  	// to, not replaced). If that behavior is desired, you can avoid this warning by using
  
  30
  >
  	// New*TypedSettingWithConverter and referring to dynamicconfig.ConvertStructure
  
  31
  >
  	// explicitly. Otherwise use nil slices and maps, including at the top level
  
  32
  >
  	// (so `[]string(nil)` instead of `[]string{}`).
  
  33
  >
  	logSharedStructureWarningsOnce.Do(func() {
  
  34
  >
  		sharedStructureWarnings.Range(func(key, path any) bool {
  
  35
  
  			softassert.Fail(logger,
  
  36
  
  				"default value contains shared structure",

  42
  
  }
  
  43
  
  44
  >
  func hasSharedStructure(v reflect.Value, path string) string {
  
shared_structure.go

  45
  >
  	// nolint:exhaustive // deliberately not exhaustive
  
  46
  >
  	switch v.Kind() {
  
  47
  >
  	case reflect.Map, reflect.Slice, reflect.Pointer:
  
  48
  >
  		if !v.IsNil() {
  
  49
  
  			return path
  
  50
  
  		}
  
  51
  >
  	case reflect.Interface:
  
shared_structure.go

  52
  >
  		if !v.IsNil() {
  
  53
  
  			return hasSharedStructure(v.Elem(), path)
  
  54
  
  		}
  
  55
  >
  	case reflect.Struct:
  
shared_structure.go

  56
  >
  		for i := range v.NumField() {
  
  57
  >
  			if p := hasSharedStructure(v.Field(i), path+"."+v.Type().Field(i).Name); p != "" {
  
  58
  
  				return p
  
  59
  
  			}

  66
  
  		}
  
  67
  
  	}
  
  68
  >
  	return ""
  
shared_structure.go

  69
  
  }

go.temporal.io/server/common/namespace/namespace.go 23 covered LOC · 6 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

  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/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/service/history/replication/executable_task_tracker_mock.go 22 covered LOC · 4 ranges

Open complete file

  271
  
  272
  
  // NewMockExecutableTaskTracker creates a new mock instance.
  
  273
  >
  func NewMockExecutableTaskTracker(ctrl *gomock.Controller) *MockExecutableTaskTracker {
  
executable_task_tracker_mock.go

  274
  >
  	mock := &MockExecutableTaskTracker{ctrl: ctrl}
  
  275
  >
  	mock.recorder = &MockExecutableTaskTrackerMockRecorder{mock}
  
  276
  >
  	return mock
  
  277
  >
  }
  
  278
  
  279
  
  // EXPECT returns an object that allows the caller to indicate expected use.
  
  280
  >
  func (m *MockExecutableTaskTracker) EXPECT() *MockExecutableTaskTrackerMockRecorder {
  
executable_task_tracker_mock.go

  281
  >
  	return m.recorder
  
  282
  >
  }
  
  283
  
  284
  
  // Cancel mocks base method.

  323
  
  324
  
  // TrackTasks mocks base method.
  
  325
  >
  func (m *MockExecutableTaskTracker) TrackTasks(exclusiveHighWatermarkInfo WatermarkInfo, arg1 ...TrackableExecutableTask) []TrackableExecutableTask {
  
executable_task_tracker_mock.go

  326
  >
  	m.ctrl.T.Helper()
  
  327
  >
  	varargs := []any{exclusiveHighWatermarkInfo}
  
  328
  >
  	for _, a := range arg1 {
  
  329
  >
  		varargs = append(varargs, a)
  
  330
  >
  	}
  
  331
  >
  	ret := m.ctrl.Call(m, "TrackTasks", varargs...)
  
  332
  >
  	ret0, _ := ret[0].([]TrackableExecutableTask)
  
  333
  >
  	return ret0
  
  334
  
  }
  
  335
  
  336
  
  // TrackTasks indicates an expected call of TrackTasks.
  
  337
  >
  func (mr *MockExecutableTaskTrackerMockRecorder) TrackTasks(exclusiveHighWatermarkInfo any, arg1 ...any) *gomock.Call {
  
executable_task_tracker_mock.go

  338
  >
  	mr.mock.ctrl.T.Helper()
  
  339
  >
  	varargs := append([]any{exclusiveHighWatermarkInfo}, arg1...)
  
  340
  >
  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrackTasks", reflect.TypeOf((*MockExecutableTaskTracker)(nil).TrackTasks), varargs...)
  
  341
  >
  }

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 {

  94
  
  }
  
  95
  
  96
  >
  func NewInt32(key string, value int32) ZapTag {
  
zap_tag.go

  97
  >
  	return ZapTag{
  
  98
  >
  		field: zap.Int32(key, value),
  
  99
  >
  	}
  
  100
  >
  }
  
  101
  
  102
  
  func NewUInt32(key string, value uint32) 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/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/errordetails/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  625
  
  }
  
  626
  
  627
  >
  func init() { file_temporal_server_api_errordetails_v1_message_proto_init() }
  
message.pb.go

  628
  >
  func file_temporal_server_api_errordetails_v1_message_proto_init() {
  
  629
  >
  	if File_temporal_server_api_errordetails_v1_message_proto != nil {
  
  630
  
  		return
  
  631
  
  	}
  
  632
  >
  	type x struct{}
  
message.pb.go

  633
  >
  	out := protoimpl.TypeBuilder{
  
  634
  >
  		File: protoimpl.DescBuilder{
  
  635
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  636
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_errordetails_v1_message_proto_rawDesc), len(file_temporal_server_api_errordetails_v1_message_proto_rawDesc)),
  
  637
  >
  			NumEnums:      0,
  
  638
  >
  			NumMessages:   10,
  
  639
  >
  			NumExtensions: 0,
  
  640
  >
  			NumServices:   0,
  
  641
  >
  		},
  
  642
  >
  		GoTypes:           file_temporal_server_api_errordetails_v1_message_proto_goTypes,
  
  643
  >
  		DependencyIndexes: file_temporal_server_api_errordetails_v1_message_proto_depIdxs,
  
  644
  >
  		MessageInfos:      file_temporal_server_api_errordetails_v1_message_proto_msgTypes,
  
  645
  >
  	}.Build()
  
  646
  >
  	File_temporal_server_api_errordetails_v1_message_proto = out.File
  
  647
  >
  	file_temporal_server_api_errordetails_v1_message_proto_goTypes = nil
  
  648
  >
  	file_temporal_server_api_errordetails_v1_message_proto_depIdxs = nil
  
  649
  
  }

go.temporal.io/server/api/health/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  300
  
  }
  
  301
  
  302
  >
  func init() { file_temporal_server_api_health_v1_message_proto_init() }
  
message.pb.go

  303
  >
  func file_temporal_server_api_health_v1_message_proto_init() {
  
  304
  >
  	if File_temporal_server_api_health_v1_message_proto != nil {
  
  305
  
  		return
  
  306
  
  	}
  
  307
  >
  	type x struct{}
  
message.pb.go

  308
  >
  	out := protoimpl.TypeBuilder{
  
  309
  >
  		File: protoimpl.DescBuilder{
  
  310
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  311
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_health_v1_message_proto_rawDesc), len(file_temporal_server_api_health_v1_message_proto_rawDesc)),
  
  312
  >
  			NumEnums:      0,
  
  313
  >
  			NumMessages:   3,
  
  314
  >
  			NumExtensions: 0,
  
  315
  >
  			NumServices:   0,
  
  316
  >
  		},
  
  317
  >
  		GoTypes:           file_temporal_server_api_health_v1_message_proto_goTypes,
  
  318
  >
  		DependencyIndexes: file_temporal_server_api_health_v1_message_proto_depIdxs,
  
  319
  >
  		MessageInfos:      file_temporal_server_api_health_v1_message_proto_msgTypes,
  
  320
  >
  	}.Build()
  
  321
  >
  	File_temporal_server_api_health_v1_message_proto = out.File
  
  322
  >
  	file_temporal_server_api_health_v1_message_proto_goTypes = nil
  
  323
  >
  	file_temporal_server_api_health_v1_message_proto_depIdxs = nil
  
  324
  
  }

go.temporal.io/server/api/historyservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  428
  
  }
  
  429
  
  430
  >
  func init() { file_temporal_server_api_historyservice_v1_service_proto_init() }
  
service.pb.go

  431
  >
  func file_temporal_server_api_historyservice_v1_service_proto_init() {
  
  432
  >
  	if File_temporal_server_api_historyservice_v1_service_proto != nil {
  
  433
  
  		return
  
  434
  
  	}
  
  435
  >
  	file_temporal_server_api_historyservice_v1_request_response_proto_init()
  
service.pb.go

  436
  >
  	type x struct{}
  
  437
  >
  	out := protoimpl.TypeBuilder{
  
  438
  >
  		File: protoimpl.DescBuilder{
  
  439
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  440
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_historyservice_v1_service_proto_rawDesc), len(file_temporal_server_api_historyservice_v1_service_proto_rawDesc)),
  
  441
  >
  			NumEnums:      0,
  
  442
  >
  			NumMessages:   0,
  
  443
  >
  			NumExtensions: 0,
  
  444
  >
  			NumServices:   1,
  
  445
  >
  		},
  
  446
  >
  		GoTypes:           file_temporal_server_api_historyservice_v1_service_proto_goTypes,
  
  447
  >
  		DependencyIndexes: file_temporal_server_api_historyservice_v1_service_proto_depIdxs,
  
  448
  >
  	}.Build()
  
  449
  >
  	File_temporal_server_api_historyservice_v1_service_proto = out.File
  
  450
  >
  	file_temporal_server_api_historyservice_v1_service_proto_goTypes = nil
  
  451
  >
  	file_temporal_server_api_historyservice_v1_service_proto_depIdxs = nil
  
  452
  
  }

go.temporal.io/server/api/matchingservice/v1/service.pb.go 20 covered LOC · 2 ranges

Open complete file

  250
  
  }
  
  251
  
  252
  >
  func init() { file_temporal_server_api_matchingservice_v1_service_proto_init() }
  
service.pb.go

  253
  >
  func file_temporal_server_api_matchingservice_v1_service_proto_init() {
  
  254
  >
  	if File_temporal_server_api_matchingservice_v1_service_proto != nil {
  
  255
  
  		return
  
  256
  
  	}
  
  257
  >
  	file_temporal_server_api_matchingservice_v1_request_response_proto_init()
  
service.pb.go

  258
  >
  	type x struct{}
  
  259
  >
  	out := protoimpl.TypeBuilder{
  
  260
  >
  		File: protoimpl.DescBuilder{
  
  261
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  262
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_matchingservice_v1_service_proto_rawDesc), len(file_temporal_server_api_matchingservice_v1_service_proto_rawDesc)),
  
  263
  >
  			NumEnums:      0,
  
  264
  >
  			NumMessages:   0,
  
  265
  >
  			NumExtensions: 0,
  
  266
  >
  			NumServices:   1,
  
  267
  >
  		},
  
  268
  >
  		GoTypes:           file_temporal_server_api_matchingservice_v1_service_proto_goTypes,
  
  269
  >
  		DependencyIndexes: file_temporal_server_api_matchingservice_v1_service_proto_depIdxs,
  
  270
  >
  	}.Build()
  
  271
  >
  	File_temporal_server_api_matchingservice_v1_service_proto = out.File
  
  272
  >
  	file_temporal_server_api_matchingservice_v1_service_proto_goTypes = nil
  
  273
  >
  	file_temporal_server_api_matchingservice_v1_service_proto_depIdxs = nil
  
  274
  
  }

go.temporal.io/server/api/metrics/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  104
  
  }
  
  105
  
  106
  >
  func init() { file_temporal_server_api_metrics_v1_message_proto_init() }
  
message.pb.go

  107
  >
  func file_temporal_server_api_metrics_v1_message_proto_init() {
  
  108
  >
  	if File_temporal_server_api_metrics_v1_message_proto != nil {
  
  109
  
  		return
  
  110
  
  	}
  
  111
  >
  	type x struct{}
  
message.pb.go

  112
  >
  	out := protoimpl.TypeBuilder{
  
  113
  >
  		File: protoimpl.DescBuilder{
  
  114
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  115
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_metrics_v1_message_proto_rawDesc), len(file_temporal_server_api_metrics_v1_message_proto_rawDesc)),
  
  116
  >
  			NumEnums:      0,
  
  117
  >
  			NumMessages:   2,
  
  118
  >
  			NumExtensions: 0,
  
  119
  >
  			NumServices:   0,
  
  120
  >
  		},
  
  121
  >
  		GoTypes:           file_temporal_server_api_metrics_v1_message_proto_goTypes,
  
  122
  >
  		DependencyIndexes: file_temporal_server_api_metrics_v1_message_proto_depIdxs,
  
  123
  >
  		MessageInfos:      file_temporal_server_api_metrics_v1_message_proto_msgTypes,
  
  124
  >
  	}.Build()
  
  125
  >
  	File_temporal_server_api_metrics_v1_message_proto = out.File
  
  126
  >
  	file_temporal_server_api_metrics_v1_message_proto_goTypes = nil
  
  127
  >
  	file_temporal_server_api_metrics_v1_message_proto_depIdxs = nil
  
  128
  
  }

go.temporal.io/server/api/namespace/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  114
  
  }
  
  115
  
  116
  >
  func init() { file_temporal_server_api_namespace_v1_message_proto_init() }
  
message.pb.go

  117
  >
  func file_temporal_server_api_namespace_v1_message_proto_init() {
  
  118
  >
  	if File_temporal_server_api_namespace_v1_message_proto != nil {
  
  119
  
  		return
  
  120
  
  	}
  
  121
  >
  	type x struct{}
  
message.pb.go

  122
  >
  	out := protoimpl.TypeBuilder{
  
  123
  >
  		File: protoimpl.DescBuilder{
  
  124
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  125
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_namespace_v1_message_proto_rawDesc), len(file_temporal_server_api_namespace_v1_message_proto_rawDesc)),
  
  126
  >
  			NumEnums:      0,
  
  127
  >
  			NumMessages:   1,
  
  128
  >
  			NumExtensions: 0,
  
  129
  >
  			NumServices:   0,
  
  130
  >
  		},
  
  131
  >
  		GoTypes:           file_temporal_server_api_namespace_v1_message_proto_goTypes,
  
  132
  >
  		DependencyIndexes: file_temporal_server_api_namespace_v1_message_proto_depIdxs,
  
  133
  >
  		MessageInfos:      file_temporal_server_api_namespace_v1_message_proto_msgTypes,
  
  134
  >
  	}.Build()
  
  135
  >
  	File_temporal_server_api_namespace_v1_message_proto = out.File
  
  136
  >
  	file_temporal_server_api_namespace_v1_message_proto_goTypes = nil
  
  137
  >
  	file_temporal_server_api_namespace_v1_message_proto_depIdxs = nil
  
  138
  
  }

go.temporal.io/server/api/persistence/v1/chasm_visibility.pb.go 20 covered LOC · 2 ranges

Open complete file

  146
  
  }
  
  147
  
  148
  >
  func init() { file_temporal_server_api_persistence_v1_chasm_visibility_proto_init() }
  
chasm_visibility.pb.go

  149
  >
  func file_temporal_server_api_persistence_v1_chasm_visibility_proto_init() {
  
  150
  >
  	if File_temporal_server_api_persistence_v1_chasm_visibility_proto != nil {
  
  151
  
  		return
  
  152
  
  	}
  
  153
  >
  	type x struct{}
  
chasm_visibility.pb.go

  154
  >
  	out := protoimpl.TypeBuilder{
  
  155
  >
  		File: protoimpl.DescBuilder{
  
  156
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  157
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_chasm_visibility_proto_rawDesc), len(file_temporal_server_api_persistence_v1_chasm_visibility_proto_rawDesc)),
  
  158
  >
  			NumEnums:      0,
  
  159
  >
  			NumMessages:   2,
  
  160
  >
  			NumExtensions: 0,
  
  161
  >
  			NumServices:   0,
  
  162
  >
  		},
  
  163
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_chasm_visibility_proto_goTypes,
  
  164
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_chasm_visibility_proto_depIdxs,
  
  165
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_chasm_visibility_proto_msgTypes,
  
  166
  >
  	}.Build()
  
  167
  >
  	File_temporal_server_api_persistence_v1_chasm_visibility_proto = out.File
  
  168
  >
  	file_temporal_server_api_persistence_v1_chasm_visibility_proto_goTypes = nil
  
  169
  >
  	file_temporal_server_api_persistence_v1_chasm_visibility_proto_depIdxs = nil
  
  170
  
  }

go.temporal.io/server/api/persistence/v1/cluster_metadata.pb.go 20 covered LOC · 2 ranges

Open complete file

  289
  
  }
  
  290
  
  291
  >
  func init() { file_temporal_server_api_persistence_v1_cluster_metadata_proto_init() }
  
cluster_metadata.pb.go

  292
  >
  func file_temporal_server_api_persistence_v1_cluster_metadata_proto_init() {
  
  293
  >
  	if File_temporal_server_api_persistence_v1_cluster_metadata_proto != nil {
  
  294
  
  		return
  
  295
  
  	}
  
  296
  >
  	type x struct{}
  
cluster_metadata.pb.go

  297
  >
  	out := protoimpl.TypeBuilder{
  
  298
  >
  		File: protoimpl.DescBuilder{
  
  299
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  300
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_cluster_metadata_proto_rawDesc), len(file_temporal_server_api_persistence_v1_cluster_metadata_proto_rawDesc)),
  
  301
  >
  			NumEnums:      0,
  
  302
  >
  			NumMessages:   5,
  
  303
  >
  			NumExtensions: 0,
  
  304
  >
  			NumServices:   0,
  
  305
  >
  		},
  
  306
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_cluster_metadata_proto_goTypes,
  
  307
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_cluster_metadata_proto_depIdxs,
  
  308
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_cluster_metadata_proto_msgTypes,
  
  309
  >
  	}.Build()
  
  310
  >
  	File_temporal_server_api_persistence_v1_cluster_metadata_proto = out.File
  
  311
  >
  	file_temporal_server_api_persistence_v1_cluster_metadata_proto_goTypes = nil
  
  312
  >
  	file_temporal_server_api_persistence_v1_cluster_metadata_proto_depIdxs = nil
  
  313
  
  }

go.temporal.io/server/api/persistence/v1/history_tree.pb.go 20 covered LOC · 2 ranges

Open complete file

  274
  
  }
  
  275
  
  276
  >
  func init() { file_temporal_server_api_persistence_v1_history_tree_proto_init() }
  
history_tree.pb.go

  277
  >
  func file_temporal_server_api_persistence_v1_history_tree_proto_init() {
  
  278
  >
  	if File_temporal_server_api_persistence_v1_history_tree_proto != nil {
  
  279
  
  		return
  
  280
  
  	}
  
  281
  >
  	type x struct{}
  
history_tree.pb.go

  282
  >
  	out := protoimpl.TypeBuilder{
  
  283
  >
  		File: protoimpl.DescBuilder{
  
  284
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  285
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_history_tree_proto_rawDesc), len(file_temporal_server_api_persistence_v1_history_tree_proto_rawDesc)),
  
  286
  >
  			NumEnums:      0,
  
  287
  >
  			NumMessages:   3,
  
  288
  >
  			NumExtensions: 0,
  
  289
  >
  			NumServices:   0,
  
  290
  >
  		},
  
  291
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_history_tree_proto_goTypes,
  
  292
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_history_tree_proto_depIdxs,
  
  293
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_history_tree_proto_msgTypes,
  
  294
  >
  	}.Build()
  
  295
  >
  	File_temporal_server_api_persistence_v1_history_tree_proto = out.File
  
  296
  >
  	file_temporal_server_api_persistence_v1_history_tree_proto_goTypes = nil
  
  297
  >
  	file_temporal_server_api_persistence_v1_history_tree_proto_depIdxs = nil
  
  298
  
  }

go.temporal.io/server/api/persistence/v1/namespaces.pb.go 20 covered LOC · 2 ranges

Open complete file

  536
  
  }
  
  537
  
  538
  >
  func init() { file_temporal_server_api_persistence_v1_namespaces_proto_init() }
  
namespaces.pb.go

  539
  >
  func file_temporal_server_api_persistence_v1_namespaces_proto_init() {
  
  540
  >
  	if File_temporal_server_api_persistence_v1_namespaces_proto != nil {
  
  541
  
  		return
  
  542
  
  	}
  
  543
  >
  	type x struct{}
  
namespaces.pb.go

  544
  >
  	out := protoimpl.TypeBuilder{
  
  545
  >
  		File: protoimpl.DescBuilder{
  
  546
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  547
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_namespaces_proto_rawDesc), len(file_temporal_server_api_persistence_v1_namespaces_proto_rawDesc)),
  
  548
  >
  			NumEnums:      0,
  
  549
  >
  			NumMessages:   8,
  
  550
  >
  			NumExtensions: 0,
  
  551
  >
  			NumServices:   0,
  
  552
  >
  		},
  
  553
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_namespaces_proto_goTypes,
  
  554
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_namespaces_proto_depIdxs,
  
  555
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_namespaces_proto_msgTypes,
  
  556
  >
  	}.Build()
  
  557
  >
  	File_temporal_server_api_persistence_v1_namespaces_proto = out.File
  
  558
  >
  	file_temporal_server_api_persistence_v1_namespaces_proto_goTypes = nil
  
  559
  >
  	file_temporal_server_api_persistence_v1_namespaces_proto_depIdxs = nil
  
  560
  
  }

go.temporal.io/server/api/persistence/v1/queue_metadata.pb.go 20 covered LOC · 2 ranges

Open complete file

  105
  
  }
  
  106
  
  107
  >
  func init() { file_temporal_server_api_persistence_v1_queue_metadata_proto_init() }
  
queue_metadata.pb.go

  108
  >
  func file_temporal_server_api_persistence_v1_queue_metadata_proto_init() {
  
  109
  >
  	if File_temporal_server_api_persistence_v1_queue_metadata_proto != nil {
  
  110
  
  		return
  
  111
  
  	}
  
  112
  >
  	type x struct{}
  
queue_metadata.pb.go

  113
  >
  	out := protoimpl.TypeBuilder{
  
  114
  >
  		File: protoimpl.DescBuilder{
  
  115
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  116
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_queue_metadata_proto_rawDesc), len(file_temporal_server_api_persistence_v1_queue_metadata_proto_rawDesc)),
  
  117
  >
  			NumEnums:      0,
  
  118
  >
  			NumMessages:   2,
  
  119
  >
  			NumExtensions: 0,
  
  120
  >
  			NumServices:   0,
  
  121
  >
  		},
  
  122
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_queue_metadata_proto_goTypes,
  
  123
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_queue_metadata_proto_depIdxs,
  
  124
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_queue_metadata_proto_msgTypes,
  
  125
  >
  	}.Build()
  
  126
  >
  	File_temporal_server_api_persistence_v1_queue_metadata_proto = out.File
  
  127
  >
  	file_temporal_server_api_persistence_v1_queue_metadata_proto_goTypes = nil
  
  128
  >
  	file_temporal_server_api_persistence_v1_queue_metadata_proto_depIdxs = nil
  
  129
  
  }

go.temporal.io/server/api/persistence/v1/tasks.pb.go 20 covered LOC · 2 ranges

Open complete file

  846
  
  }
  
  847
  
  848
  >
  func init() { file_temporal_server_api_persistence_v1_tasks_proto_init() }
  
tasks.pb.go

  849
  >
  func file_temporal_server_api_persistence_v1_tasks_proto_init() {
  
  850
  >
  	if File_temporal_server_api_persistence_v1_tasks_proto != nil {
  
  851
  
  		return
  
  852
  
  	}
  
  853
  >
  	type x struct{}
  
tasks.pb.go

  854
  >
  	out := protoimpl.TypeBuilder{
  
  855
  >
  		File: protoimpl.DescBuilder{
  
  856
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  857
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_persistence_v1_tasks_proto_rawDesc), len(file_temporal_server_api_persistence_v1_tasks_proto_rawDesc)),
  
  858
  >
  			NumEnums:      0,
  
  859
  >
  			NumMessages:   8,
  
  860
  >
  			NumExtensions: 0,
  
  861
  >
  			NumServices:   0,
  
  862
  >
  		},
  
  863
  >
  		GoTypes:           file_temporal_server_api_persistence_v1_tasks_proto_goTypes,
  
  864
  >
  		DependencyIndexes: file_temporal_server_api_persistence_v1_tasks_proto_depIdxs,
  
  865
  >
  		MessageInfos:      file_temporal_server_api_persistence_v1_tasks_proto_msgTypes,
  
  866
  >
  	}.Build()
  
  867
  >
  	File_temporal_server_api_persistence_v1_tasks_proto = out.File
  
  868
  >
  	file_temporal_server_api_persistence_v1_tasks_proto_goTypes = nil
  
  869
  >
  	file_temporal_server_api_persistence_v1_tasks_proto_depIdxs = nil
  
  870
  
  }

go.temporal.io/server/api/token/v1/message.pb.go 20 covered LOC · 2 ranges

Open complete file

  785
  
  }
  
  786
  
  787
  >
  func init() { file_temporal_server_api_token_v1_message_proto_init() }
  
message.pb.go

  788
  >
  func file_temporal_server_api_token_v1_message_proto_init() {
  
  789
  >
  	if File_temporal_server_api_token_v1_message_proto != nil {
  
  790
  
  		return
  
  791
  
  	}
  
  792
  >
  	type x struct{}
  
message.pb.go

  793
  >
  	out := protoimpl.TypeBuilder{
  
  794
  >
  		File: protoimpl.DescBuilder{
  
  795
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  796
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_token_v1_message_proto_rawDesc), len(file_temporal_server_api_token_v1_message_proto_rawDesc)),
  
  797
  >
  			NumEnums:      0,
  
  798
  >
  			NumMessages:   7,
  
  799
  >
  			NumExtensions: 0,
  
  800
  >
  			NumServices:   0,
  
  801
  >
  		},
  
  802
  >
  		GoTypes:           file_temporal_server_api_token_v1_message_proto_goTypes,
  
  803
  >
  		DependencyIndexes: file_temporal_server_api_token_v1_message_proto_depIdxs,
  
  804
  >
  		MessageInfos:      file_temporal_server_api_token_v1_message_proto_msgTypes,
  
  805
  >
  	}.Build()
  
  806
  >
  	File_temporal_server_api_token_v1_message_proto = out.File
  
  807
  >
  	file_temporal_server_api_token_v1_message_proto_goTypes = nil
  
  808
  >
  	file_temporal_server_api_token_v1_message_proto_depIdxs = nil
  
  809
  
  }

go.temporal.io/server/api/visibilityservice/v1/request_response.pb.go 20 covered LOC · 2 ranges

Open complete file

  402
  
  }
  
  403
  
  404
  >
  func init() { file_temporal_server_api_visibilityservice_v1_request_response_proto_init() }
  
request_response.pb.go

  405
  >
  func file_temporal_server_api_visibilityservice_v1_request_response_proto_init() {
  
  406
  >
  	if File_temporal_server_api_visibilityservice_v1_request_response_proto != nil {
  
  407
  
  		return
  
  408
  
  	}
  
  409
  >
  	type x struct{}
  
request_response.pb.go

  410
  >
  	out := protoimpl.TypeBuilder{
  
  411
  >
  		File: protoimpl.DescBuilder{
  
  412
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  413
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_visibilityservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_visibilityservice_v1_request_response_proto_rawDesc)),
  
  414
  >
  			NumEnums:      0,
  
  415
  >
  			NumMessages:   5,
  
  416
  >
  			NumExtensions: 0,
  
  417
  >
  			NumServices:   0,
  
  418
  >
  		},
  
  419
  >
  		GoTypes:           file_temporal_server_api_visibilityservice_v1_request_response_proto_goTypes,
  
  420
  >
  		DependencyIndexes: file_temporal_server_api_visibilityservice_v1_request_response_proto_depIdxs,
  
  421
  >
  		MessageInfos:      file_temporal_server_api_visibilityservice_v1_request_response_proto_msgTypes,
  
  422
  >
  	}.Build()
  
  423
  >
  	File_temporal_server_api_visibilityservice_v1_request_response_proto = out.File
  
  424
  >
  	file_temporal_server_api_visibilityservice_v1_request_response_proto_goTypes = nil
  
  425
  >
  	file_temporal_server_api_visibilityservice_v1_request_response_proto_depIdxs = nil
  
  426
  
  }

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

Open complete file

  91
  
  }
  
  92
  
  93
  >
  func init() { file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() }
  
service.pb.go

  94
  >
  func file_temporal_server_chasm_lib_activity_proto_v1_service_proto_init() {
  
  95
  >
  	if File_temporal_server_chasm_lib_activity_proto_v1_service_proto != nil {
  
  96
  
  		return
  
  97
  
  	}
  
  98
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init()
  
service.pb.go

  99
  >
  	type x struct{}
  
  100
  >
  	out := protoimpl.TypeBuilder{
  
  101
  >
  		File: protoimpl.DescBuilder{
  
  102
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  103
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc)),
  
  104
  >
  			NumEnums:      0,
  
  105
  >
  			NumMessages:   0,
  
  106
  >
  			NumExtensions: 0,
  
  107
  >
  			NumServices:   1,
  
  108
  >
  		},
  
  109
  >
  		GoTypes:           file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes,
  
  110
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs,
  
  111
  >
  	}.Build()
  
  112
  >
  	File_temporal_server_chasm_lib_activity_proto_v1_service_proto = out.File
  
  113
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes = nil
  
  114
  >
  	file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs = nil
  
  115
  
  }

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

Open complete file

  148
  
  }
  
  149
  
  150
  >
  func init() { file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  151
  >
  func file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_init() {
  
  152
  >
  	if File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto != nil {
  
  153
  
  		return
  
  154
  
  	}
  
  155
  >
  	type x struct{}
  
tasks.pb.go

  156
  >
  	out := protoimpl.TypeBuilder{
  
  157
  >
  		File: protoimpl.DescBuilder{
  
  158
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  159
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_rawDesc)),
  
  160
  >
  			NumEnums:      0,
  
  161
  >
  			NumMessages:   2,
  
  162
  >
  			NumExtensions: 0,
  
  163
  >
  			NumServices:   0,
  
  164
  >
  		},
  
  165
  >
  		GoTypes:           file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes,
  
  166
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs,
  
  167
  >
  		MessageInfos:      file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_msgTypes,
  
  168
  >
  	}.Build()
  
  169
  >
  	File_temporal_server_chasm_lib_callback_proto_v1_tasks_proto = out.File
  
  170
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_goTypes = nil
  
  171
  >
  	file_temporal_server_chasm_lib_callback_proto_v1_tasks_proto_depIdxs = nil
  
  172
  
  }

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

Open complete file

  71
  
  }
  
  72
  
  73
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() }
  
service.pb.go

  74
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_init() {
  
  75
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto != nil {
  
  76
  
  		return
  
  77
  
  	}
  
  78
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_request_response_proto_init()
  
service.pb.go

  79
  >
  	type x struct{}
  
  80
  >
  	out := protoimpl.TypeBuilder{
  
  81
  >
  		File: protoimpl.DescBuilder{
  
  82
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  83
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_rawDesc)),
  
  84
  >
  			NumEnums:      0,
  
  85
  >
  			NumMessages:   0,
  
  86
  >
  			NumExtensions: 0,
  
  87
  >
  			NumServices:   1,
  
  88
  >
  		},
  
  89
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes,
  
  90
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs,
  
  91
  >
  	}.Build()
  
  92
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto = out.File
  
  93
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_goTypes = nil
  
  94
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_service_proto_depIdxs = nil
  
  95
  
  }

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

Open complete file

  354
  
  }
  
  355
  
  356
  >
  func init() { file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() }
  
tasks.pb.go

  357
  >
  func file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_init() {
  
  358
  >
  	if File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto != nil {
  
  359
  
  		return
  
  360
  
  	}
  
  361
  >
  	type x struct{}
  
tasks.pb.go

  362
  >
  	out := protoimpl.TypeBuilder{
  
  363
  >
  		File: protoimpl.DescBuilder{
  
  364
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  365
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc), len(file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_rawDesc)),
  
  366
  >
  			NumEnums:      0,
  
  367
  >
  			NumMessages:   7,
  
  368
  >
  			NumExtensions: 0,
  
  369
  >
  			NumServices:   0,
  
  370
  >
  		},
  
  371
  >
  		GoTypes:           file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes,
  
  372
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs,
  
  373
  >
  		MessageInfos:      file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_msgTypes,
  
  374
  >
  	}.Build()
  
  375
  >
  	File_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto = out.File
  
  376
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_goTypes = nil
  
  377
  >
  	file_temporal_server_chasm_lib_nexusoperation_proto_v1_tasks_proto_depIdxs = nil
  
  378
  
  }

go.temporal.io/server/chasm/lib/workflow/gen/workflowpb/v1/state.pb.go 20 covered LOC · 2 ranges

Open complete file

  211
  
  }
  
  212
  
  213
  >
  func init() { file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_init() }
  
state.pb.go

  214
  >
  func file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_init() {
  
  215
  >
  	if File_temporal_server_chasm_lib_workflow_proto_v1_state_proto != nil {
  
  216
  
  		return
  
  217
  
  	}
  
  218
  >
  	type x struct{}
  
state.pb.go

  219
  >
  	out := protoimpl.TypeBuilder{
  
  220
  >
  		File: protoimpl.DescBuilder{
  
  221
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  222
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_rawDesc), len(file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_rawDesc)),
  
  223
  >
  			NumEnums:      0,
  
  224
  >
  			NumMessages:   3,
  
  225
  >
  			NumExtensions: 0,
  
  226
  >
  			NumServices:   0,
  
  227
  >
  		},
  
  228
  >
  		GoTypes:           file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_goTypes,
  
  229
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_depIdxs,
  
  230
  >
  		MessageInfos:      file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_msgTypes,
  
  231
  >
  	}.Build()
  
  232
  >
  	File_temporal_server_chasm_lib_workflow_proto_v1_state_proto = out.File
  
  233
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_goTypes = nil
  
  234
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_state_proto_depIdxs = nil
  
  235
  
  }

go.temporal.io/server/chasm/lib/workflow/gen/workflowpb/v1/update_state.pb.go 20 covered LOC · 2 ranges

Open complete file

  113
  
  }
  
  114
  
  115
  >
  func init() { file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_init() }
  
update_state.pb.go

  116
  >
  func file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_init() {
  
  117
  >
  	if File_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto != nil {
  
  118
  
  		return
  
  119
  
  	}
  
  120
  >
  	type x struct{}
  
update_state.pb.go

  121
  >
  	out := protoimpl.TypeBuilder{
  
  122
  >
  		File: protoimpl.DescBuilder{
  
  123
  >
  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  
  124
  >
  			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_rawDesc), len(file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_rawDesc)),
  
  125
  >
  			NumEnums:      0,
  
  126
  >
  			NumMessages:   1,
  
  127
  >
  			NumExtensions: 0,
  
  128
  >
  			NumServices:   0,
  
  129
  >
  		},
  
  130
  >
  		GoTypes:           file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_goTypes,
  
  131
  >
  		DependencyIndexes: file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_depIdxs,
  
  132
  >
  		MessageInfos:      file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_msgTypes,
  
  133
  >
  	}.Build()
  
  134
  >
  	File_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto = out.File
  
  135
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_goTypes = nil
  
  136
  >
  	file_temporal_server_chasm_lib_workflow_proto_v1_update_state_proto_depIdxs = nil
  
  137
  
  }

go.temporal.io/server/common/util/wildcard.go 20 covered LOC · 7 ranges

Open complete file

  18
  
  // WildCardStringToRegexps converts a given slices of string patterns to a slice of regular expressions matching
  
  19
  
  // wildcards (*) with any substring.
  
  20
  >
  func WildCardStringsToRegexp(patterns []string) (*regexp.Regexp, error) {
  
wildcard.go

  21
  >
  	var result strings.Builder
  
  22
  >
  	result.WriteRune('^')
  
  23
  >
  	for i, pattern := range patterns {
  
  24
  >
  		result.WriteRune('(')
  
  25
  >
  		first := true
  
  26
  >
  		for literal := range strings.SplitSeq(pattern, "*") {
  
  27
  >
  			if !first {
  
  28
  
  				// Replace * with .*
  
  29
  
  				result.WriteString(".*")
  
  30
  
  			}
  
  31
  >
  			result.WriteString(regexp.QuoteMeta(literal))
  
wildcard.go

  32
  >
  			first = false
  
  33
  
  		}
  
  34
  >
  		result.WriteRune(')')
  
wildcard.go

  35
  >
  		if i < len(patterns)-1 {
  
  36
  >
  			result.WriteRune('|')
  
wildcard.go

  37
  >
  		}
  
  38
  
  	}
  
  39
  >
  	result.WriteRune('$')
  
wildcard.go

  40
  >
  	return regexp.Compile(result.String())
  
  41
  
  }
  
  42
  
  43
  
  // MustWildCardStringsToRegexp is like WildCardStringsToRegexp but panics on error.
  
  44
  >
  func MustWildCardStringsToRegexp(patterns []string) *regexp.Regexp {
  
wildcard.go

  45
  >
  	re, err := WildCardStringsToRegexp(patterns)
  
  46
  >
  	if err != nil {
  
  47
  
  		panic(err) //nolint:forbidigo // Must* functions conventionally panic on error.
  
  48
  
  	}
  
  49
  >
  	return re
  
wildcard.go

  50
  
  }

go.temporal.io/server/service/history/replication/executable_unknown_task.go 20 covered LOC · 1 range

Open complete file

  32
  
  	taskCreationTime time.Time,
  
  33
  
  	task any,
  
  34
  >
  ) *ExecutableUnknownTask {
  
executable_unknown_task.go

  35
  >
  	return &ExecutableUnknownTask{
  
  36
  >
  		ProcessToolBox: processToolBox,
  
  37
  >
  
  38
  >
  		ExecutableTask: NewExecutableTask(
  
  39
  >
  			processToolBox,
  
  40
  >
  			taskID,
  
  41
  >
  			metrics.UnknownTaskScope,
  
  42
  >
  			taskCreationTime,
  
  43
  >
  			time.Now().UTC(),
  
  44
  >
  			"sourceCluster",
  
  45
  >
  			ClusterShardKey{
  
  46
  >
  				ClusterID: 0,
  
  47
  >
  				ShardID:   0,
  
  48
  >
  			},
  
  49
  >
  			nil,
  
  50
  >
  		),
  
  51
  >
  		task: task,
  
  52
  >
  	}
  
  53
  >
  }
  
  54
  
  55
  
  func (e *ExecutableUnknownTask) QueueID() any {

go.temporal.io/server/service/history/replication/executable_task.go 16 covered LOC · 1 range

Open complete file

  137
  
  	sourceShardKey ClusterShardKey,
  
  138
  
  	replicationTask *replicationspb.ReplicationTask,
  
  139
  >
  ) *ExecutableTaskImpl {
  
executable_task.go

  140
  >
  	return &ExecutableTaskImpl{
  
  141
  >
  		ProcessToolBox:         processToolBox,
  
  142
  >
  		taskID:                 taskID,
  
  143
  >
  		metricsTag:             metricsTag,
  
  144
  >
  		taskCreationTime:       taskCreationTime,
  
  145
  >
  		taskReceivedTime:       taskReceivedTime,
  
  146
  >
  		sourceClusterName:      sourceClusterName,
  
  147
  >
  		sourceShardKey:         sourceShardKey,
  
  148
  >
  		taskPriority:           replicationTask.GetPriority(),
  
  149
  >
  		replicationTask:        replicationTask,
  
  150
  >
  		taskState:              taskStatePending,
  
  151
  >
  		attempt:                1,
  
  152
  >
  		markPoisonPillAttempts: 0,
  
  153
  >
  	}
  
  154
  >
  }
  
  155
  
  156
  
  func (e *ExecutableTaskImpl) TaskID() int64 {

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

  112
  
  }
  
  113
  
  114
  >
  func (r *defaultReplicationResolver) SetGlobalFlag(isGlobal bool) {
  
replication_resolver.go

  115
  >
  	r.isGlobalNamespace = isGlobal
  
  116
  >
  }
  
  117
  
  118
  
  func (r *defaultReplicationResolver) SetActiveCluster(clusterName string) {

go.temporal.io/server/common/persistence/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/testing/testhooks/test_impl.go 15 covered LOC · 4 ranges

Open complete file

  37
  
  //
  
  38
  
  // TestHooks should be used sparingly, see comment on TestHooks.
  
  39
  >
  func Get[T any, S any](th TestHooks, key Key[T, S], scope S) (T, bool) {
  
test_impl.go

  40
  >
  	var zero T
  
  41
  >
  	if th.data == nil {
  
  42
  >
  		// This means TestHooks wasn't created via NewTestHooks. Ignore.
  
test_impl.go

  43
  >
  		return zero, false
  
  44
  >
  	}
  
  45
  
  	if val, ok := th.data.Load(hookKey{key.id, scope}); ok {
  
  46
  
  		return val.(T), true //nolint:revive

  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/build/build.go 14 covered LOC · 2 ranges

Open complete file

  27
  
  )
  
  28
  
  29
  >
  func init() {
  
build.go

  30
  >
  	buildInfo, ok := debug.ReadBuildInfo()
  
  31
  >
  	if !ok {
  
  32
  
  		return
  
  33
  
  	}
  
  34
  
  35
  >
  	InfoData.Available = true
  
build.go

  36
  >
  	InfoData.GoVersion = buildInfo.GoVersion
  
  37
  >
  
  38
  >
  	for _, setting := range buildInfo.Settings {
  
  39
  >
  		switch setting.Key {
  
  40
  >
  		case "GOARCH":
  
  41
  >
  			InfoData.GoArch = setting.Value
  
  42
  >
  		case "GOOS":
  
  43
  >
  			InfoData.GoOs = setting.Value
  
  44
  >
  		case "CGO_ENABLED":
  
  45
  >
  			InfoData.CgoEnabled = setting.Value == "1"
  
  46
  
  		case "vcs.revision":
  
  47
  
  			InfoData.GitRevision = setting.Value

go.temporal.io/server/common/dynamicconfig/gradual_change.go 14 covered LOC · 3 ranges

Open complete file

  25
  
  // StaticGradualChange returns a GradualChange whose Value always returns def and whose When
  
  26
  
  // always returns a time in the past.
  
  27
  >
  func StaticGradualChange[T any](def T) GradualChange[T] {
  
gradual_change.go

  28
  >
  	return GradualChange[T]{New: def}
  
  29
  >
  }
  
  30
  
  31
  
  // Value returns the value for the given key at the given time.

  56
  
  // of type GradualChange into a GradualChange.
  
  57
  
  // nolint:revive // cognitive-complexity // this looks complicated but each case is fairly simple
  
  58
  >
  func ConvertGradualChange[T any](def T) func(v any) (GradualChange[T], error) {
  
gradual_change.go

  59
  >
  	changeConverter := ConvertStructure(StaticGradualChange(def))
  
  60
  >
  
  61
  >
  	// Call this once so that if it's going to panic, it panics at static init time.
  
  62
  >
  	_, _ = changeConverter(nil)
  
  63
  >
  
  64
  >
  	switch reflect.TypeFor[T]() {
  
  65
  >
  	case reflect.TypeFor[bool]():
  
  66
  >
  		return func(v any) (GradualChange[T], error) {
  
  67
  
  			if b, err := convertBool(v); err == nil {
  
  68
  
  				var change GradualChange[T]

  72
  
  			return changeConverter(v)
  
  73
  
  		}
  
  74
  >
  	case reflect.TypeFor[int]():
  
gradual_change.go

  75
  >
  		return func(v any) (GradualChange[T], error) {
  
  76
  
  			if i, err := convertInt(v); err == nil {
  
  77
  
  				var change GradualChange[T]

go.temporal.io/server/common/persistence/visibility/store/elasticsearch/visibility_store.go 12 covered LOC · 3 ranges

Open complete file

  101
  
  	}
  
  102
  
  103
  >
  	defaultSorter = func() []elastic.Sorter {
  
visibility_store.go

  104
  >
  		ret := make([]elastic.Sorter, 0, len(defaultSorterFields))
  
  105
  >
  		for _, item := range defaultSorterFields {
  
  106
  >
  			fs := elastic.NewFieldSort(item.name)
  
  107
  >
  			if item.desc {
  
  108
  >
  				fs.Desc()
  
  109
  >
  			}
  
  110
  >
  			if item.missing_first {
  
  111
  >
  				fs.Missing("_first")
  
  112
  >
  			} else {
  
  113
  
  				fs.Missing("_last")
  
  114
  
  			}
  
  115
  >
  			ret = append(ret, fs)
  
visibility_store.go

  116
  
  		}
  
  117
  >
  		return ret
  
visibility_store.go

  118
  
  	}()
  
  119

go.temporal.io/server/service/history/replication/bi_direction_stream.go 12 covered LOC · 1 range

Open complete file

  69
  
  	metricsHandler metrics.Handler,
  
  70
  
  	logger log.Logger,
  
  71
  >
  ) *BiDirectionStreamImpl[Req, Resp] {
  
bi_direction_stream.go

  72
  >
  	return &BiDirectionStreamImpl[Req, Resp]{
  
  73
  >
  		ctx:            context.Background(),
  
  74
  >
  		clientProvider: clientProvider,
  
  75
  >
  		metricsHandler: metricsHandler,
  
  76
  >
  		logger:         logger,
  
  77
  >
  
  78
  >
  		status:          streamStatusInitialized,
  
  79
  >
  		channel:         make(chan StreamResp[Resp], defaultChanSize),
  
  80
  >
  		streamingClient: nil,
  
  81
  >
  	}
  
  82
  >
  }
  
  83
  
  84
  
  func (s *BiDirectionStreamImpl[Req, Resp]) Send(

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/metrics/defs_base.go 10 covered LOC · 1 range

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

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

Open complete file

  160
  
  161
  
  // FromClusterIDTag returns a new from cluster tag.
  
  162
  >
  func FromClusterIDTag(value int32) Tag {
  
tags.go

  163
  >
  	return Tag{Key: fromCluster, Value: strconv.FormatInt(int64(value), 10)}
  
  164
  >
  }
  
  165
  
  166
  
  // ToClusterIDTag returns a new to cluster tag.
  
  167
  >
  func ToClusterIDTag(value int32) Tag {
  
tags.go

  168
  >
  	return Tag{Key: toCluster, Value: strconv.FormatInt(int64(value), 10)}
  
  169
  >
  }
  
  170
  
  171
  
  // UnsafeTaskQueueTag returns a new task queue tag.

  455
  
  }
  
  456
  
  457
  >
  func OperationTag(value string) Tag {
  
tags.go

  458
  >
  	return Tag{Key: OperationTagName, Value: value}
  
  459
  >
  }
  
  460
  
  461
  
  func StringTag(key string, value string) Tag {

go.temporal.io/server/common/persistence/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/primitives/timestamp/duration.go 9 covered LOC · 3 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 {

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

Open complete file

  54
  
  	logger log.Logger,
  
  55
  
  	metricsHandler metrics.Handler,
  
  56
  >
  ) *ExecutableTaskTrackerImpl {
  
executable_task_tracker.go

  57
  >
  	return &ExecutableTaskTrackerImpl{
  
  58
  >
  		logger:         logger,
  
  59
  >
  		metricsHandler: metricsHandler,
  
  60
  >
  
  61
  >
  		exclusiveHighWatermarkInfo: nil,
  
  62
  >
  		taskQueue:                  list.New(),
  
  63
  >
  	}
  
  64
  >
  }
  
  65
  
  66
  
  // TrackTasks add tasks for tracking, return valid tasks (dedup)

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/workflow/task_generator_provider.go 7 covered LOC · 2 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 {

go.temporal.io/server/common/channel/shutdown_once.go 6 covered LOC · 1 range

Open complete file

  26
  
  )
  
  27
  
  28
  >
  func NewShutdownOnce() *ShutdownOnceImpl {
  
shutdown_once.go

  29
  >
  	return &ShutdownOnceImpl{
  
  30
  >
  		status:  shutdownOnceStatusOpen,
  
  31
  >
  		channel: make(chan struct{}),
  
  32
  >
  	}
  
  33
  >
  }
  
  34
  
  35
  
  func (c *ShutdownOnceImpl) Shutdown() {

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/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/replication/stream_receiver_flow_controller.go 6 covered LOC · 1 range

Open complete file

  34
  
  )
  
  35
  
  36
  >
  func NewReceiverFlowControl(signals map[enumsspb.TaskPriority]FlowControlSignalProvider, config *configs.Config) *streamReceiverFlowControllerImpl {
  
stream_receiver_flow_controller.go

  37
  >
  	return &streamReceiverFlowControllerImpl{
  
  38
  >
  		signalsProvider: signals,
  
  39
  >
  		config:          config,
  
  40
  >
  	}
  
  41
  >
  }
  
  42
  
  43
  
  func (s *streamReceiverFlowControllerImpl) GetFlowControlInfo(priority enumsspb.TaskPriority) FlowControlInfo {

go.temporal.io/server/service/history/tasks/key.go 6 covered LOC · 1 range

Open complete file

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

  24
  
  25
  
  // Counter obtains a counter for the given name.
  
  26
  >
  func (*noopMetricsHandler) Counter(string) CounterIface {
  
noop_impl.go

  27
  >
  	return NoopCounterMetricFunc
  
  28
  >
  }
  
  29
  
  30
  
  // Gauge obtains a gauge for the given name.

  53
  
  }
  
  54
  
  55
  >
  var NoopCounterMetricFunc = CounterFunc(func(i int64, t ...Tag) {})
  
noop_impl.go

  56
  
  var NoopGaugeMetricFunc = GaugeFunc(func(f float64, t ...Tag) {})
  
  57
  
  var NoopTimerMetricFunc = TimerFunc(func(d time.Duration, t ...Tag) {})

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/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/service/history/replication/metrics.go 5 covered LOC · 3 ranges

Open complete file

  9
  
  func TaskOperationTag(
  
  10
  
  	replicationTask *replicationspb.ReplicationTask,
  
  11
  >
  ) string {
  
metrics.go

  12
  >
  	if replicationTask == nil {
  
  13
  
  		return "__unknown__"
  
  14
  
  	}
  
  15
  >
  	switch replicationTask.GetTaskType() {
  
metrics.go

  16
  
  	case enumsspb.REPLICATION_TASK_TYPE_SYNC_SHARD_STATUS_TASK: // TODO to be deprecated
  
  17
  
  		return "__unknown__"

  34
  
  	case enumsspb.REPLICATION_TASK_TYPE_DELETE_EXECUTION_TASK:
  
  35
  
  		return metrics.DeleteExecutionReplicationTaskScope
  
  36
  >
  	default:
  
metrics.go

  37
  >
  		return metrics.NoopTaskScope
  
  38
  
  	}
  
  39
  
  }

go.temporal.io/server/service/history/replication/stream.go 5 covered LOC · 1 range

Open complete file

  35
  
  	allClusterInfo map[string]cluster.ClusterInformation,
  
  36
  
  	clusterID int32,
  
  37
  >
  ) (string, int32, error) {
  
stream.go

  38
  >
  	for clusterName, clusterInfo := range allClusterInfo {
  
  39
  >
  		if int32(clusterInfo.InitialFailoverVersion) == clusterID {
  
  40
  >
  			return clusterName, clusterInfo.ShardCount, nil
  
  41
  >
  		}
  
  42
  
  	}
  
  43
  
  	return "", 0, serviceerror.NewInternalf("unknown cluster ID: %v", clusterID)

go.temporal.io/server/service/history/replication/stream_receiver_flow_controller_mock.go 5 covered LOC · 1 range

Open complete file

  30
  
  31
  
  // NewMockReceiverFlowController creates a new mock instance.
  
  32
  >
  func NewMockReceiverFlowController(ctrl *gomock.Controller) *MockReceiverFlowController {
  
stream_receiver_flow_controller_mock.go

  33
  >
  	mock := &MockReceiverFlowController{ctrl: ctrl}
  
  34
  >
  	mock.recorder = &MockReceiverFlowControllerMockRecorder{mock}
  
  35
  >
  	return mock
  
  36
  >
  }
  
  37
  
  38
  
  // EXPECT returns an object that allows the caller to indicate expected use.

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

Open complete file

  56
  
  // tasks within the CHASM framework.
  
  57
  
  // The format of the returned FQN is: "libName.name"
  
  58
  >
  func FullyQualifiedName(libName, name string) string {
  
library.go

  59
  >
  	return libName + "." + name
  
  60
  >
  }

go.temporal.io/server/chasm/registrable_component.go 3 covered LOC · 1 range

Open complete file

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

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

go.temporal.io/server/common/dynamicconfig/key.go 3 covered LOC · 1 range

Open complete file

  13
  
  )
  
  14
  
  15
  >
  func MakeKey(s string) Key {
  
key.go

  16
  >
  	return Key{handle: unique.Make(strings.ToLower(s))}
  
  17
  >
  }
  
  18
  
  19
  
  func (k Key) String() string {

go.temporal.io/server/common/log/noop_logger.go 3 covered LOC · 1 range

Open complete file

  10
  
  11
  
  // NewNoopLogger return a noopLogger
  
  12
  >
  func NewNoopLogger() *noopLogger {
  
noop_logger.go

  13
  >
  	return &noopLogger{}
  
  14
  >
  }
  
  15
  
  16
  
  func (n *noopLogger) Debug(string, ...tag.Tag)  {}

go.temporal.io/server/common/membership/hostinfo.go 3 covered LOC · 1 range

Open complete file

  12
  
  13
  
  // NewHostInfoFromAddress creates a new HostInfo instance from a socket address.
  
  14
  >
  func NewHostInfoFromAddress(address string) HostInfo {
  
hostinfo.go

  15
  >
  	return hostAddress(address)
  
  16
  >
  }
  
  17
  
  18
  
  // hostAddress is a HostInfo implementation that uses a string as the address and identity.

go.temporal.io/server/common/payload/payload.go 3 covered LOC · 1 range

Open complete file

  30
  
  }
  
  31
  
  32
  >
  func Encode(value any) (*commonpb.Payload, error) {
  
payload.go

  33
  >
  	return defaultDataConverter.ToPayload(value)
  
  34
  >
  }
  
  35
  
  36
  
  func Decode(p *commonpb.Payload, valuePtr any) error {

go.temporal.io/server/common/persistence/nosql/nosqlplugin/cassandra/translator/translator_plugin.go 3 covered LOC · 1 range

Open complete file

  22
  
  // RegisterPlugin adds an auth plugin to the plugin registry
  
  23
  
  // it is only safe to use from a package init function
  
  24
  >
  func RegisterTranslator(name string, plugin TranslatorPlugin) {
  
translator_plugin.go

  25
  >
  	translators[name] = plugin
  
  26
  >
  }
  
  27
  
  28
  
  func LookupTranslator(name string) (TranslatorPlugin, error) {

go.temporal.io/server/common/persistence/persistence_rate_limited_clients.go 3 covered LOC · 1 range

Open complete file

  1182
  
  	baseAPI string,
  
  1183
  
  	taskCategory tasks.Category,
  
  1184
  >
  ) string {
  
persistence_rate_limited_clients.go

  1185
  >
  	return baseAPI + taskCategory.Name()
  
  1186
  >
  }

go.temporal.io/server/common/persistence/sql/store.go 3 covered LOC · 2 ranges

Open complete file

  19
  
  20
  
  // RegisterPlugin will register a SQL plugin
  
  21
  >
  func RegisterPlugin(pluginName string, plugin sqlplugin.Plugin) {
  
store.go

  22
  >
  	if _, ok := supportedPlugins[pluginName]; ok {
  
  23
  
  		panic("plugin " + pluginName + " already registered")
  
  24
  
  	}
  
  25
  >
  	supportedPlugins[pluginName] = plugin
  
store.go

  26
  
  }
  
  27

go.temporal.io/server/common/primitives/timestamp/time.go 3 covered LOC · 2 ranges

Open complete file

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

  14
  >
  	if t == nil {
  
  15
  
  		return time.Time{}
  
  16
  
  	}
  
  17
  >
  	return t.AsTime()
  
time.go

  18
  
  }
  
  19

go.temporal.io/server/service/history/tasks/category.go 3 covered LOC · 1 range

Open complete file

  100
  
  }
  
  101
  
  102
  >
  func (c Category) Name() string {
  
category.go

  103
  >
  	return c.name
  
  104
  >
  }
  
  105
  
  106
  
  func (c Category) Type() CategoryType {

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

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...) }
  
  84
  
  func (c TimerFunc) Record(v time.Duration, tags ...Tag) { c(v, tags...) }

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

TestProcessMessage_TrackSubmit_SingleStack

Covered source