Merge cockroachdb#108100 cockroachdb#108107 cockroachdb#108108

108100: server: init secondary tenant servers with proper clock parameters r=pavelkalinnikov a=knz

We need to share the code path to initialize the HLC clock between all types of servers.

Fixes cockroachdb#108098.
Epic: CRDB-26687


108107: ccl/multiregionccl: skip TestMultiRegionDataDriven r=maryliag,chengxiong-ruan a=kvoli

Failing consistently on nightly stress, skip.

Informs: cockroachdb#98020

Epic: none

Release note: None

108108: kvprober: remove unnecessary checks to avoid flakes r=joshimhoff a=joshimhoff

Fixes cockroachdb#107873.

**kvprober: remove unnecessary checks to avoid flakes**

This commit removes two unnecessary checks, to avoid flakes. The removed checks can cause flakes, since they require all probes (of a certain type) to fail, even tho the test server is not configured to fail probes until after server startup. That is, there is a race condition. The checks are also unnecessary. What we really care about is the checks that follow the deleted ones: That the ten probes run within test all fail, since those happen after the test server is configured to fail probes.

Release note: None.
Epic: None.

Co-authored-by: Raphael 'kena' Poss <[email protected]>
Co-authored-by: Austen McClernon <[email protected]>
Co-authored-by: Josh Imhoff <[email protected]>

Author: 4 people

pkg/ccl/multiregionccl/datadriven_test.go

@@ -114,6 +114,7 @@ func TestMultiRegionDataDriven(t *testing.T) {
 	defer log.Scope(t).Close(t)
 
 	skip.UnderRace(t, "flaky test")
+	skip.WithIssue(t, 98020)
 	ctx := context.Background()
 	datadriven.Walk(t, datapathutils.TestDataPath(t), func(t *testing.T, path string) {
 		ds := datadrivenTestState{}

pkg/kv/kvprober/kvprober_integration_test.go

@@ -171,8 +171,6 @@ func TestProberDoesReadsAndWrites(t *testing.T) {
 			p.WriteProbe(ctx, s.DB())
 		}
 
-		// Expect all read probes to fail but write probes & planning to succeed.
-		require.Equal(t, p.Metrics().ReadProbeAttempts.Count(), p.Metrics().ReadProbeFailures.Count())
 		// kvprober is running in background, so more than ten probes may be run.
 		require.GreaterOrEqual(t, p.Metrics().ReadProbeFailures.Count(), int64(10))
 
@@ -220,8 +218,6 @@ func TestProberDoesReadsAndWrites(t *testing.T) {
 			p.WriteProbe(ctx, s.DB())
 		}
 
-		// Expect all write probes to fail but read probes & planning to succeed.
-		require.Equal(t, p.Metrics().WriteProbeAttempts.Count(), p.Metrics().WriteProbeFailures.Count())
 		// kvprober is running in background, so more than ten probes may be run.
 		require.GreaterOrEqual(t, p.Metrics().WriteProbeFailures.Count(), int64(10))
 

pkg/server/server.go

@@ -239,21 +239,9 @@ func NewServer(cfg Config, stopper *stop.Stopper) (serverctl.ServerStartupInterf
 		panic(errors.New("no tracer set in AmbientCtx"))
 	}
 
-	maxOffset := time.Duration(cfg.MaxOffset)
-	toleratedOffset := cfg.ToleratedOffset()
-	var clock *hlc.Clock
-	if cfg.ClockDevicePath != "" {
-		ptpClock, err := ptp.MakeClock(ctx, cfg.ClockDevicePath)
-		if err != nil {
-			return nil, errors.Wrap(err, "instantiating clock source")
-		}
-		clock = hlc.NewClock(ptpClock, maxOffset, toleratedOffset)
-	} else if cfg.TestingKnobs.Server != nil &&
-		cfg.TestingKnobs.Server.(*TestingKnobs).WallClock != nil {
-		clock = hlc.NewClock(cfg.TestingKnobs.Server.(*TestingKnobs).WallClock,
-			maxOffset, toleratedOffset)
-	} else {
-		clock = hlc.NewClockWithSystemTimeSource(maxOffset, toleratedOffset)
+	clock, err := newClockFromConfig(ctx, cfg.BaseConfig)
+	if err != nil {
+		return nil, err
 	}
 	registry := metric.NewRegistry()
 	ruleRegistry := metric.NewRuleRegistry()
@@ -1319,6 +1307,27 @@ func NewServer(cfg Config, stopper *stop.Stopper) (serverctl.ServerStartupInterf
 	return lateBoundServer, err
 }
 
+// newClockFromConfig creates a HLC clock from the server configuration.
+func newClockFromConfig(ctx context.Context, cfg BaseConfig) (*hlc.Clock, error) {
+	maxOffset := time.Duration(cfg.MaxOffset)
+	toleratedOffset := cfg.ToleratedOffset()
+	var clock *hlc.Clock
+	if cfg.ClockDevicePath != "" {
+		ptpClock, err := ptp.MakeClock(ctx, cfg.ClockDevicePath)
+		if err != nil {
+			return nil, errors.Wrap(err, "instantiating clock source")
+		}
+		clock = hlc.NewClock(ptpClock, maxOffset, toleratedOffset)
+	} else if cfg.TestingKnobs.Server != nil &&
+		cfg.TestingKnobs.Server.(*TestingKnobs).WallClock != nil {
+		clock = hlc.NewClock(cfg.TestingKnobs.Server.(*TestingKnobs).WallClock,
+			maxOffset, toleratedOffset)
+	} else {
+		clock = hlc.NewClockWithSystemTimeSource(maxOffset, toleratedOffset)
+	}
+	return clock, nil
+}
+
 // ClusterSettings returns the cluster settings.
 func (s *topLevelServer) ClusterSettings() *cluster.Settings {
 	return s.st

pkg/server/tenant.go

@@ -978,9 +978,10 @@ func makeTenantSQLServerArgs(
 	// the instance ID (once known) as a tag.
 	startupCtx = baseCfg.AmbientCtx.AnnotateCtx(startupCtx)
 
-	maxOffset := time.Duration(baseCfg.MaxOffset)
-	toleratedOffset := baseCfg.ToleratedOffset()
-	clock := hlc.NewClockWithSystemTimeSource(maxOffset, toleratedOffset)
+	clock, err := newClockFromConfig(startupCtx, baseCfg)
+	if err != nil {
+		return sqlServerArgs{}, err
+	}
 
 	registry := metric.NewRegistry()
 	ruleRegistry := metric.NewRuleRegistry()