diff --git a/pkg/BUILD.bazel b/pkg/BUILD.bazel index 1ebd41deb25a..5d687178dda1 100644 --- a/pkg/BUILD.bazel +++ b/pkg/BUILD.bazel @@ -142,6 +142,7 @@ ALL_TESTS = [ "//pkg/cmd/roachprod-microbench:roachprod-microbench_test", "//pkg/cmd/roachtest/clusterstats:clusterstats_test", "//pkg/cmd/roachtest/option:option_test", + "//pkg/cmd/roachtest/registry:registry_test", "//pkg/cmd/roachtest/roachtestutil/mixedversion:mixedversion_test", "//pkg/cmd/roachtest/roachtestutil:roachtestutil_test", "//pkg/cmd/roachtest/tests:tests_test", @@ -1074,6 +1075,7 @@ GO_TARGETS = [ "//pkg/cmd/roachtest/option:option", "//pkg/cmd/roachtest/option:option_test", "//pkg/cmd/roachtest/registry:registry", + "//pkg/cmd/roachtest/registry:registry_test", "//pkg/cmd/roachtest/roachtestutil/clusterupgrade:clusterupgrade", "//pkg/cmd/roachtest/roachtestutil/mixedversion:mixedversion", "//pkg/cmd/roachtest/roachtestutil/mixedversion:mixedversion_test", diff --git a/pkg/cmd/roachtest/main_test.go b/pkg/cmd/roachtest/main_test.go index cd637877211c..2fb4a37d7163 100644 --- a/pkg/cmd/roachtest/main_test.go +++ b/pkg/cmd/roachtest/main_test.go @@ -37,10 +37,12 @@ func makeRegistry(names ...string) testRegistryImpl { for _, name := range names { r.Add(registry.TestSpec{ - Name: name, - Owner: OwnerUnitTest, - Run: dummyRun, - Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + Name: name, + Owner: OwnerUnitTest, + Run: dummyRun, + Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) } diff --git a/pkg/cmd/roachtest/registry/BUILD.bazel b/pkg/cmd/roachtest/registry/BUILD.bazel index a9c83f83ac46..d76348eedd9a 100644 --- a/pkg/cmd/roachtest/registry/BUILD.bazel +++ b/pkg/cmd/roachtest/registry/BUILD.bazel @@ -1,4 +1,4 @@ -load("@io_bazel_rules_go//go:def.bzl", "go_library") +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") go_library( name = "registry", @@ -19,3 +19,14 @@ go_library( "@com_github_prometheus_client_golang//prometheus/promauto", ], ) + +go_test( + name = "registry_test", + srcs = ["test_spec_test.go"], + args = ["-test.timeout=295s"], + embed = [":registry"], + deps = [ + "//pkg/cmd/roachtest/spec", + "@com_github_stretchr_testify//require", + ], +) diff --git a/pkg/cmd/roachtest/registry/test_spec.go b/pkg/cmd/roachtest/registry/test_spec.go index 59ccdf71a1a0..a8cf0bc38f42 100644 --- a/pkg/cmd/roachtest/registry/test_spec.go +++ b/pkg/cmd/roachtest/registry/test_spec.go @@ -54,6 +54,15 @@ type TestSpec struct { // N.B. performance tests may have different requirements than correctness tests, e.g., machine type/architecture. // Thus, they must be opted into explicitly via this field. Benchmark bool + + // CompatibleClouds is the set of clouds this test can run on (e.g. AllClouds, + // OnlyGCE, etc). Must be set. + CompatibleClouds CloudSet + + // Suites is the set of suites this test is part of (e.g. Nightly, Weekly, + // etc). Must be set, even if empty (see ManualOnly). + Suites SuiteSet + // Tags is a set of tags associated with the test that allow grouping // tests. If no tags are specified, the set ["default"] is automatically // given. @@ -196,6 +205,221 @@ const ( MetamorphicLeases ) +var allClouds = []string{spec.Local, spec.GCE, spec.AWS, spec.Azure} + +// CloudSet represents a set of clouds. +// +// Instances of CloudSet are immutable. The uninitialized (zero) value is not +// valid. +type CloudSet struct { + // m contains only values from allClouds. + m map[string]struct{} +} + +// AllClouds contains all clouds. +var AllClouds = Clouds(allClouds...) + +// AllExceptLocal contains all clouds except Local. +var AllExceptLocal = AllClouds.NoLocal() + +// AllExceptAWS contains all clouds except AWS. +var AllExceptAWS = AllClouds.NoAWS() + +// OnlyGCE contains only the GCE cloud. +var OnlyGCE = Clouds(spec.GCE) + +// OnlyLocal contains only the GCE cloud. +var OnlyLocal = Clouds(spec.Local) + +// Clouds creates a CloudSet for the given clouds. Cloud names must be one of: +// spec.Local, spec.GCE, spec.AWS, spec.Azure. +func Clouds(clouds ...string) CloudSet { + assertValidValues(allClouds, clouds...) + return CloudSet{m: addToSet(nil, clouds...)} +} + +// NoLocal removes the Local cloud and returns the new set. +func (cs CloudSet) NoLocal() CloudSet { + return CloudSet{m: removeFromSet(cs.m, spec.Local)} +} + +// NoAWS removes the AWS cloud and returns the new set. +func (cs CloudSet) NoAWS() CloudSet { + return CloudSet{m: removeFromSet(cs.m, spec.AWS)} +} + +// NoAzure removes the Azure cloud and returns the new set. +func (cs CloudSet) NoAzure() CloudSet { + return CloudSet{m: removeFromSet(cs.m, spec.Azure)} +} + +// Contains returns true if the set contains the given cloud. +func (cs CloudSet) Contains(cloud string) bool { + cs.AssertInitialized() + _, ok := cs.m[cloud] + return ok +} + +func (cs CloudSet) String() string { + cs.AssertInitialized() + return setToString(allClouds, cs.m) +} + +// AssertInitialized panics if the CloudSet is the zero value. +func (cs CloudSet) AssertInitialized() { + if cs.m == nil { + panic("CloudSet not initialized") + } +} + +// Suite names. +const ( + Nightly = "nightly" + Weekly = "weekly" + ReleaseQualification = "release_qualification" + ORM = "orm" + Driver = "driver" + Tool = "tool" + Smoketest = "smoketest" + Quick = "quick" + Fixtures = "fixtures" + Pebble = "pebble" + PebbleNightlyWrite = "pebble_nightly_write" + PebbleNightlyYCSB = "pebble_nightly_ycsb" + PebbleNightlyYCSBRace = "pebble_nightly_ycsb_race" + Roachtest = "roachtest" +) + +var allSuites = []string{ + Nightly, Weekly, ReleaseQualification, ORM, Driver, Tool, Smoketest, Quick, Fixtures, + Pebble, PebbleNightlyWrite, PebbleNightlyYCSB, PebbleNightlyYCSBRace, Roachtest, +} + +// SuiteSet represents a set of suites. +// +// Instances of SuiteSet are immutable. The uninitialized (zero) value is not +// valid. +type SuiteSet struct { + // m contains only values from allSuites. + m map[string]struct{} +} + +// ManualOnly is used for tests that are not part of any suite; these tests are +// only run manually. +var ManualOnly = Suites() + +// Suites creates a SuiteSet with the given suites. Only the constants above are +// valid values. +func Suites(suites ...string) SuiteSet { + assertValidValues(allSuites, suites...) + return SuiteSet{m: addToSet(nil, suites...)} +} + +// Contains returns true if the set contains the given suite. +func (ss SuiteSet) Contains(suite string) bool { + ss.AssertInitialized() + _, ok := ss.m[suite] + return ok +} + +func (ss SuiteSet) String() string { + return setToString(allSuites, ss.m) +} + +// AssertInitialized panics if the SuiteSet is the zero value. +func (ss SuiteSet) AssertInitialized() { + if ss.m == nil { + panic("SuiteSet not initialized") + } +} + +// CrossCheckTags verifies that the CompatibleClouds and Suites values match those of the tags. +func (t *TestSpec) CrossCheckTags() { + // Check that CompatibleClouds + Suites would make the same determination as + // tags for what test to run for Nightly/Weekly and GCE/AWS. + var expected, actual struct { + nightlyGCE bool + weeklyGCE bool + nightlyAWS bool + weeklyAWS bool + } + + expected.nightlyGCE = matchesAll(t.Tags, []string{"default"}) || matchesAll(t.Tags, []string{"aws"}) + expected.weeklyGCE = matchesAll(t.Tags, []string{"weekly"}) + expected.nightlyAWS = matchesAll(t.Tags, []string{"aws"}) + expected.weeklyAWS = matchesAll(t.Tags, []string{"aws-weekly"}) + + actual.nightlyGCE = t.Suites.Contains(Nightly) && t.CompatibleClouds.Contains(spec.GCE) + actual.weeklyGCE = t.Suites.Contains(Weekly) && t.CompatibleClouds.Contains(spec.GCE) + actual.nightlyAWS = t.Suites.Contains(Nightly) && t.CompatibleClouds.Contains(spec.AWS) + actual.weeklyAWS = t.Suites.Contains(Weekly) && t.CompatibleClouds.Contains(spec.AWS) + + if actual != expected { + panic(fmt.Sprintf("CompatibleClouds/Suites inconsistent with Tags\nexpected: %#v\nactual: %#v\nclouds: %s suites:%s tags:%v\n", expected, actual, t.CompatibleClouds, t.Suites, t.Tags)) + } + + otherSuiteTags := fmt.Sprintf("%v", removeFromSet(t.Tags, "default", "weekly", "aws-weekly", "aws", "owner-"+string(t.Owner))) + otherSuites := fmt.Sprintf("%v", removeFromSet(t.Suites.m, Weekly, Nightly)) + if otherSuiteTags != otherSuites && !(otherSuiteTags == "map[manual:{}]" && otherSuites == "map[]") { + panic(fmt.Sprintf("Suites inconsistent with Tags\nexpected: %v\nactual: %v\nsuites:%s tags:%v\n", otherSuiteTags, otherSuites, t.Suites, t.Tags)) + } +} + +// assertValidValues asserts that the given values exist in the validValues slice. +func assertValidValues(validValues []string, values ...string) { + for _, v := range values { + found := false + for _, valid := range validValues { + if valid == v { + found = true + break + } + } + if !found { + panic(fmt.Sprintf("invalid value %q (valid values: %v)", v, validValues)) + } + } +} + +// addToSet returns a new set that is the initial set with the given values added. +func addToSet(initial map[string]struct{}, values ...string) map[string]struct{} { + m := make(map[string]struct{}) + for k := range initial { + m[k] = struct{}{} + } + for _, v := range values { + m[v] = struct{}{} + } + return m +} + +// removeFromSet returns a new set that is the initial set with the given values removed. +func removeFromSet(initial map[string]struct{}, values ...string) map[string]struct{} { + m := make(map[string]struct{}) + for k := range initial { + m[k] = struct{}{} + } + for _, v := range values { + delete(m, v) + } + return m +} + +// setToString returns the elements of a set, in the relative order in which they appear +// in validValues. Returns "" if the set is empty. +func setToString(validValues []string, m map[string]struct{}) string { + var elems []string + for _, v := range validValues { + if _, ok := m[v]; ok { + elems = append(elems, v) + } + } + if len(elems) == 0 { + return "" + } + return strings.Join(elems, ",") +} + func matchesAll(testTags map[string]struct{}, filterTags []string) bool { for _, tag := range filterTags { negate := false diff --git a/pkg/cmd/roachtest/registry/test_spec_test.go b/pkg/cmd/roachtest/registry/test_spec_test.go new file mode 100644 index 000000000000..a6cd3575708f --- /dev/null +++ b/pkg/cmd/roachtest/registry/test_spec_test.go @@ -0,0 +1,45 @@ +// Copyright 2023 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +package registry + +import ( + "testing" + + "github.com/cockroachdb/cockroach/pkg/cmd/roachtest/spec" + "github.com/stretchr/testify/require" +) + +func TestCloudSet(t *testing.T) { + expect := func(c CloudSet, exp string) { + require.Equal(t, exp, c.String()) + } + expect(AllClouds, "local,gce,aws,azure") + expect(AllExceptAWS, "local,gce,azure") + expect(AllExceptLocal, "gce,aws,azure") + expect(AllExceptLocal.NoAWS(), "gce,azure") + expect(AllClouds.NoAWS().NoAzure(), "local,gce") + + require.True(t, AllExceptAWS.Contains(spec.GCE)) + require.True(t, AllExceptAWS.Contains(spec.Local)) + require.False(t, AllExceptAWS.Contains(spec.AWS)) +} + +func TestSuiteSet(t *testing.T) { + expect := func(c SuiteSet, exp string) { + require.Equal(t, exp, c.String()) + } + s := Suites(Nightly, Weekly) + expect(s, "nightly,weekly") + require.True(t, s.Contains(Nightly)) + require.True(t, s.Contains(Weekly)) + require.False(t, s.Contains(ReleaseQualification)) + expect(ManualOnly, "") +} diff --git a/pkg/cmd/roachtest/test_registry.go b/pkg/cmd/roachtest/test_registry.go index 6be4b0f6fd9a..6c704f526005 100644 --- a/pkg/cmd/roachtest/test_registry.go +++ b/pkg/cmd/roachtest/test_registry.go @@ -75,6 +75,7 @@ func (r *testRegistryImpl) Add(spec registry.TestSpec) { fmt.Fprintf(os.Stderr, "%+v\n", err) os.Exit(1) } + spec.CrossCheckTags() r.m[spec.Name] = &spec } @@ -102,6 +103,9 @@ func (r *testRegistryImpl) prepareSpec(spec *registry.TestSpec) error { return fmt.Errorf("%s: Name must match this regexp: %s", spec.Name, testNameRE) } + spec.CompatibleClouds.AssertInitialized() + spec.Suites.AssertInitialized() + if spec.Run == nil { return fmt.Errorf("%s: must specify Run", spec.Name) } diff --git a/pkg/cmd/roachtest/test_test.go b/pkg/cmd/roachtest/test_test.go index 24aaabc69ce9..daaeb87dfe6b 100644 --- a/pkg/cmd/roachtest/test_test.go +++ b/pkg/cmd/roachtest/test_test.go @@ -113,10 +113,12 @@ func TestRunnerRun(t *testing.T) { r := mkReg(t) r.Add(registry.TestSpec{ - Name: "pass", - Owner: OwnerUnitTest, - Run: func(ctx context.Context, t test.Test, c cluster.Cluster) {}, - Cluster: r.MakeClusterSpec(0), + Name: "pass", + Owner: OwnerUnitTest, + Run: func(ctx context.Context, t test.Test, c cluster.Cluster) {}, + Cluster: r.MakeClusterSpec(0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) r.Add(registry.TestSpec{ Name: "fail", @@ -124,7 +126,9 @@ func TestRunnerRun(t *testing.T) { Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { t.Fatal("failed") }, - Cluster: r.MakeClusterSpec(0), + Cluster: r.MakeClusterSpec(0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) r.Add(registry.TestSpec{ Name: "errors", @@ -133,7 +137,9 @@ func TestRunnerRun(t *testing.T) { t.Errorf("first %s", "error") t.Errorf("second error") }, - Cluster: r.MakeClusterSpec(0), + Cluster: r.MakeClusterSpec(0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) r.Add(registry.TestSpec{ Name: "panic", @@ -145,7 +151,9 @@ func TestRunnerRun(t *testing.T) { idx := rand.Intn(2) + 1 // definitely out of bounds t.L().Printf("boom %d", sl[idx]) }, - Cluster: r.MakeClusterSpec(0), + Cluster: r.MakeClusterSpec(0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) testCases := []struct { @@ -217,7 +225,9 @@ func TestRunnerEncryptionAtRest(t *testing.T) { atomic.StoreInt32(&sawEncrypted, 1) } }, - Cluster: r.MakeClusterSpec(0), + Cluster: r.MakeClusterSpec(0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) rt := setupRunnerTest(t, r, nil) @@ -350,10 +360,12 @@ func TestRunnerTestTimeout(t *testing.T) { debugMode: NoDebug, } test := registry.TestSpec{ - Name: `timeout`, - Owner: OwnerUnitTest, - Timeout: 10 * time.Millisecond, - Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + Name: `timeout`, + Owner: OwnerUnitTest, + Timeout: 10 * time.Millisecond, + Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { <-ctx.Done() }, @@ -385,20 +397,24 @@ func TestRegistryPrepareSpec(t *testing.T) { }{ { registry.TestSpec{ - Name: "a", - Owner: OwnerUnitTest, - Run: dummyRun, - Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + Name: "a", + Owner: OwnerUnitTest, + Run: dummyRun, + Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }, "", []string{"a"}, }, { registry.TestSpec{ - Name: "illegal *[]", - Owner: OwnerUnitTest, - Run: dummyRun, - Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + Name: "illegal *[]", + Owner: OwnerUnitTest, + Run: dummyRun, + Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }, `illegal \*\[\]: Name must match this regexp: `, nil, @@ -431,9 +447,11 @@ func runExitCodeTest(t *testing.T, injectedError error) error { runner := newUnitTestRunner(cr, stopper) r := mkReg(t) r.Add(registry.TestSpec{ - Name: "boom", - Owner: OwnerUnitTest, - Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + Name: "boom", + Owner: OwnerUnitTest, + Cluster: spec.MakeClusterSpec(spec.GCE, "", 0), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if injectedError != nil { t.Fatal(injectedError) diff --git a/pkg/cmd/roachtest/tests/acceptance.go b/pkg/cmd/roachtest/tests/acceptance.go index b8b312abfe37..a2c24f775e9a 100644 --- a/pkg/cmd/roachtest/tests/acceptance.go +++ b/pkg/cmd/roachtest/tests/acceptance.go @@ -93,6 +93,8 @@ func registerAcceptance(r registry.Registry) { Skip: tc.skip, EncryptionSupport: tc.encryptionSupport, Timeout: 10 * time.Minute, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.Quick), Tags: registry.Tags("default", "quick"), } diff --git a/pkg/cmd/roachtest/tests/activerecord.go b/pkg/cmd/roachtest/tests/activerecord.go index 902f7ac88c4a..0744f5ced761 100644 --- a/pkg/cmd/roachtest/tests/activerecord.go +++ b/pkg/cmd/roachtest/tests/activerecord.go @@ -246,12 +246,14 @@ func registerActiveRecord(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "activerecord", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - NativeLibs: registry.LibGEOS, - Tags: registry.Tags(`default`, `orm`), - Run: runActiveRecord, - Leases: registry.MetamorphicLeases, + Name: "activerecord", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + NativeLibs: registry.LibGEOS, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), + Run: runActiveRecord, + Leases: registry.MetamorphicLeases, }) } diff --git a/pkg/cmd/roachtest/tests/admission_control_elastic_backup.go b/pkg/cmd/roachtest/tests/admission_control_elastic_backup.go index 4c773c631128..9633278687eb 100644 --- a/pkg/cmd/roachtest/tests/admission_control_elastic_backup.go +++ b/pkg/cmd/roachtest/tests/admission_control_elastic_backup.go @@ -37,12 +37,14 @@ import ( // in roachperf. func registerElasticControlForBackups(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "admission-control/elastic-backup", - Owner: registry.OwnerAdmissionControl, - Benchmark: true, - Tags: registry.Tags(`weekly`), - Cluster: r.MakeClusterSpec(4, spec.CPU(8)), - Leases: registry.MetamorphicLeases, + Name: "admission-control/elastic-backup", + Owner: registry.OwnerAdmissionControl, + Benchmark: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), + Cluster: r.MakeClusterSpec(4, spec.CPU(8)), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().NodeCount < 4 { t.Fatalf("expected at least 4 nodes, found %d", c.Spec().NodeCount) diff --git a/pkg/cmd/roachtest/tests/admission_control_elastic_cdc.go b/pkg/cmd/roachtest/tests/admission_control_elastic_cdc.go index 45823f596ec6..8d624c177355 100644 --- a/pkg/cmd/roachtest/tests/admission_control_elastic_cdc.go +++ b/pkg/cmd/roachtest/tests/admission_control_elastic_cdc.go @@ -30,13 +30,15 @@ import ( // an increase in foreground latency. func registerElasticControlForCDC(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "admission-control/elastic-cdc", - Owner: registry.OwnerAdmissionControl, - Benchmark: true, - Tags: registry.Tags(`weekly`), - Cluster: r.MakeClusterSpec(4, spec.CPU(8)), - RequiresLicense: true, - Leases: registry.MetamorphicLeases, + Name: "admission-control/elastic-cdc", + Owner: registry.OwnerAdmissionControl, + Benchmark: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), + Cluster: r.MakeClusterSpec(4, spec.CPU(8)), + RequiresLicense: true, + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().NodeCount < 4 { t.Fatalf("expected at least 4 nodes, found %d", c.Spec().NodeCount) diff --git a/pkg/cmd/roachtest/tests/admission_control_index_overload.go b/pkg/cmd/roachtest/tests/admission_control_index_overload.go index 028fa1fa5aa6..4afcf4ceab01 100644 --- a/pkg/cmd/roachtest/tests/admission_control_index_overload.go +++ b/pkg/cmd/roachtest/tests/admission_control_index_overload.go @@ -33,12 +33,14 @@ import ( // queries, but the intent is to measure the impact of the index creation. func registerIndexOverload(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "admission-control/index-overload", - Owner: registry.OwnerAdmissionControl, - Benchmark: true, - Tags: registry.Tags("weekly"), - Cluster: r.MakeClusterSpec(4, spec.CPU(8)), - Leases: registry.MetamorphicLeases, + Name: "admission-control/index-overload", + Owner: registry.OwnerAdmissionControl, + Benchmark: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags("weekly"), + Cluster: r.MakeClusterSpec(4, spec.CPU(8)), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { crdbNodes := c.Spec().NodeCount - 1 workloadNode := c.Spec().NodeCount diff --git a/pkg/cmd/roachtest/tests/admission_control_multi_store_overload.go b/pkg/cmd/roachtest/tests/admission_control_multi_store_overload.go index 508f09a16b34..4705412b3586 100644 --- a/pkg/cmd/roachtest/tests/admission_control_multi_store_overload.go +++ b/pkg/cmd/roachtest/tests/admission_control_multi_store_overload.go @@ -92,12 +92,14 @@ func registerMultiStoreOverload(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "admission-control/multi-store-with-overload", - Owner: registry.OwnerAdmissionControl, - Benchmark: true, - Tags: registry.Tags(`weekly`), - Cluster: r.MakeClusterSpec(2, spec.CPU(8), spec.SSD(2)), - Leases: registry.MetamorphicLeases, + Name: "admission-control/multi-store-with-overload", + Owner: registry.OwnerAdmissionControl, + Benchmark: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), + Cluster: r.MakeClusterSpec(2, spec.CPU(8), spec.SSD(2)), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runKV(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/admission_control_multitenant_fairness.go b/pkg/cmd/roachtest/tests/admission_control_multitenant_fairness.go index d7492e184318..eb1d6bea0636 100644 --- a/pkg/cmd/roachtest/tests/admission_control_multitenant_fairness.go +++ b/pkg/cmd/roachtest/tests/admission_control_multitenant_fairness.go @@ -92,6 +92,8 @@ func registerMultiTenantFairness(r registry.Registry) { Owner: registry.OwnerAdmissionControl, Benchmark: true, Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), NonReleaseBlocker: false, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runMultiTenantFairness(ctx, t, c, s) diff --git a/pkg/cmd/roachtest/tests/admission_control_snapshot_overload.go b/pkg/cmd/roachtest/tests/admission_control_snapshot_overload.go index f17b9dc5d4de..7b9f1be2d0d4 100644 --- a/pkg/cmd/roachtest/tests/admission_control_snapshot_overload.go +++ b/pkg/cmd/roachtest/tests/admission_control_snapshot_overload.go @@ -39,12 +39,14 @@ import ( // make it shorter. func registerSnapshotOverload(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "admission-control/snapshot-overload", - Owner: registry.OwnerAdmissionControl, - Benchmark: true, - Tags: registry.Tags(`weekly`), - Cluster: r.MakeClusterSpec(4, spec.CPU(8)), - Leases: registry.MetamorphicLeases, + Name: "admission-control/snapshot-overload", + Owner: registry.OwnerAdmissionControl, + Benchmark: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), + Cluster: r.MakeClusterSpec(4, spec.CPU(8)), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().NodeCount < 4 { t.Fatalf("expected at least 4 nodes, found %d", c.Spec().NodeCount) diff --git a/pkg/cmd/roachtest/tests/admission_control_tpcc_overload.go b/pkg/cmd/roachtest/tests/admission_control_tpcc_overload.go index c4b6f6d59fb0..2b4676dd5088 100644 --- a/pkg/cmd/roachtest/tests/admission_control_tpcc_overload.go +++ b/pkg/cmd/roachtest/tests/admission_control_tpcc_overload.go @@ -165,6 +165,8 @@ func registerTPCCOverload(r registry.Registry) { Name: name, Owner: registry.OwnerAdmissionControl, Benchmark: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), Tags: registry.Tags(`weekly`), Cluster: r.MakeClusterSpec(s.Nodes+1, spec.CPU(s.CPUs)), Run: s.run, @@ -188,8 +190,10 @@ func registerTPCCSevereOverload(r registry.Registry) { Benchmark: true, // TODO(abaptist): This test will require a lot of admission control work // to pass. Just putting it here to make easy to run at any time. - Skip: "#89142", - Cluster: r.MakeClusterSpec(7, spec.CPU(8)), + Skip: "#89142", + Cluster: r.MakeClusterSpec(7, spec.CPU(8)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { roachNodes := c.Range(1, c.Spec().NodeCount-1) workloadNode := c.Spec().NodeCount diff --git a/pkg/cmd/roachtest/tests/allocation_bench.go b/pkg/cmd/roachtest/tests/allocation_bench.go index ab657bdfa3ee..1b880d049034 100644 --- a/pkg/cmd/roachtest/tests/allocation_bench.go +++ b/pkg/cmd/roachtest/tests/allocation_bench.go @@ -276,6 +276,8 @@ func registerAllocationBenchSpec(r registry.Registry, allocSpec allocationBenchS specOptions..., ), NonReleaseBlocker: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runAllocationBench(ctx, t, c, allocSpec) }, diff --git a/pkg/cmd/roachtest/tests/allocator.go b/pkg/cmd/roachtest/tests/allocator.go index 39c1bc502030..a638c54ebeeb 100644 --- a/pkg/cmd/roachtest/tests/allocator.go +++ b/pkg/cmd/roachtest/tests/allocator.go @@ -148,33 +148,39 @@ func registerAllocator(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: `replicate/up/1to3`, - Owner: registry.OwnerKV, - Benchmark: true, - Cluster: r.MakeClusterSpec(4), - Leases: registry.MetamorphicLeases, + Name: `replicate/up/1to3`, + Owner: registry.OwnerKV, + Benchmark: true, + Cluster: r.MakeClusterSpec(4), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runAllocator(ctx, t, c, 1, 10.0) }, }) r.Add(registry.TestSpec{ - Name: `replicate/rebalance/3to5`, - Owner: registry.OwnerKV, - Benchmark: true, - Cluster: r.MakeClusterSpec(6), - Leases: registry.MetamorphicLeases, + Name: `replicate/rebalance/3to5`, + Owner: registry.OwnerKV, + Benchmark: true, + Cluster: r.MakeClusterSpec(6), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runAllocator(ctx, t, c, 3, 42.0) }, }) r.Add(registry.TestSpec{ - Name: `replicate/wide`, - Owner: registry.OwnerKV, - Benchmark: true, - Timeout: 10 * time.Minute, - Cluster: r.MakeClusterSpec(9, spec.CPU(1)), - Leases: registry.MetamorphicLeases, - Run: runWideReplication, + Name: `replicate/wide`, + Owner: registry.OwnerKV, + Benchmark: true, + Timeout: 10 * time.Minute, + Cluster: r.MakeClusterSpec(9, spec.CPU(1)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Run: runWideReplication, }) } diff --git a/pkg/cmd/roachtest/tests/alterpk.go b/pkg/cmd/roachtest/tests/alterpk.go index a6c199507664..edc842c144e1 100644 --- a/pkg/cmd/roachtest/tests/alterpk.go +++ b/pkg/cmd/roachtest/tests/alterpk.go @@ -182,17 +182,21 @@ func registerAlterPK(r registry.Registry) { Owner: registry.OwnerSQLFoundations, // Use a 4 node cluster -- 3 nodes will run cockroach, and the last will be the // workload driver node. - Cluster: r.MakeClusterSpec(4), - Leases: registry.MetamorphicLeases, - Run: runAlterPKBank, + Cluster: r.MakeClusterSpec(4), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Run: runAlterPKBank, }) r.Add(registry.TestSpec{ Name: "alterpk-tpcc-250", Owner: registry.OwnerSQLFoundations, // Use a 4 node cluster -- 3 nodes will run cockroach, and the last will be the // workload driver node. - Cluster: r.MakeClusterSpec(4, spec.CPU(32)), - Leases: registry.MetamorphicLeases, + Cluster: r.MakeClusterSpec(4, spec.CPU(32)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runAlterPKTPCC(ctx, t, c, 250 /* warehouses */, true /* expensiveChecks */) }, @@ -202,8 +206,10 @@ func registerAlterPK(r registry.Registry) { Owner: registry.OwnerSQLFoundations, // Use a 4 node cluster -- 3 nodes will run cockroach, and the last will be the // workload driver node. - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runAlterPKTPCC(ctx, t, c, 500 /* warehouses */, false /* expensiveChecks */) }, diff --git a/pkg/cmd/roachtest/tests/asyncpg.go b/pkg/cmd/roachtest/tests/asyncpg.go index 167e0dd37f9a..f01b4a7c1155 100644 --- a/pkg/cmd/roachtest/tests/asyncpg.go +++ b/pkg/cmd/roachtest/tests/asyncpg.go @@ -139,11 +139,13 @@ func registerAsyncpg(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "asyncpg", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1, spec.CPU(16), spec.UbuntuVersion(vm.FocalFossa)), - Tags: registry.Tags(`default`, `orm`), - Leases: registry.MetamorphicLeases, + Name: "asyncpg", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1, spec.CPU(16), spec.UbuntuVersion(vm.FocalFossa)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runAsyncpg(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/autoupgrade.go b/pkg/cmd/roachtest/tests/autoupgrade.go index eecccf0fd5a6..5a90c54bf1e0 100644 --- a/pkg/cmd/roachtest/tests/autoupgrade.go +++ b/pkg/cmd/roachtest/tests/autoupgrade.go @@ -252,9 +252,11 @@ func registerAutoUpgrade(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: `autoupgrade`, - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(5), + Name: `autoupgrade`, + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(5), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { pred, err := release.LatestPredecessor(t.BuildVersion()) if err != nil { diff --git a/pkg/cmd/roachtest/tests/awsdms.go b/pkg/cmd/roachtest/tests/awsdms.go index 8ab383d858f0..7e74665c44df 100644 --- a/pkg/cmd/roachtest/tests/awsdms.go +++ b/pkg/cmd/roachtest/tests/awsdms.go @@ -188,12 +188,14 @@ func dmsDescribeTasksInput( func registerAWSDMS(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "awsdms", - Owner: registry.OwnerMigrations, - Cluster: r.MakeClusterSpec(1), - Tags: registry.Tags(`weekly`, `aws-weekly`), - Leases: registry.MetamorphicLeases, - Run: runAWSDMS, + Name: "awsdms", + Owner: registry.OwnerMigrations, + Cluster: r.MakeClusterSpec(1), + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`, `aws-weekly`), + Leases: registry.MetamorphicLeases, + Run: runAWSDMS, }) } diff --git a/pkg/cmd/roachtest/tests/backup.go b/pkg/cmd/roachtest/tests/backup.go index f433293b3891..07041848ba43 100644 --- a/pkg/cmd/roachtest/tests/backup.go +++ b/pkg/cmd/roachtest/tests/backup.go @@ -217,6 +217,8 @@ func registerBackupNodeShutdown(r registry.Registry) { Cluster: backupNodeRestartSpec, EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { gatewayNode := 2 nodeToShutdown := 3 @@ -239,6 +241,8 @@ func registerBackupNodeShutdown(r registry.Registry) { Cluster: backupNodeRestartSpec, EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { gatewayNode := 2 nodeToShutdown := 2 @@ -387,6 +391,8 @@ func registerBackup(r registry.Registry) { Owner: registry.OwnerDisasterRecovery, Benchmark: true, Cluster: backup2TBSpec, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), EncryptionSupport: registry.EncryptionAlwaysDisabled, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { rows := rows2TiB @@ -436,6 +442,8 @@ func registerBackup(r registry.Registry) { Cluster: r.MakeClusterSpec(3), EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != item.machine { t.Skip("backup assumeRole is only configured to run on "+item.machine, "") @@ -531,10 +539,11 @@ func registerBackup(r registry.Registry) { for _, item := range []struct { kmsProvider string machine string + clouds registry.CloudSet tags map[string]struct{} }{ - {kmsProvider: "GCS", machine: spec.GCE}, - {kmsProvider: "AWS", machine: spec.AWS, tags: registry.Tags("aws")}, + {kmsProvider: "GCS", machine: spec.GCE, clouds: registry.AllExceptAWS}, + {kmsProvider: "AWS", machine: spec.AWS, clouds: registry.AllClouds, tags: registry.Tags("aws")}, } { item := item r.Add(registry.TestSpec{ @@ -543,6 +552,8 @@ func registerBackup(r registry.Registry) { Cluster: KMSSpec, EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, + CompatibleClouds: item.clouds, + Suites: registry.Suites(registry.Nightly), Tags: item.tags, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != item.machine { @@ -679,6 +690,8 @@ func registerBackup(r registry.Registry) { Leases: registry.MetamorphicLeases, Timeout: 1 * time.Hour, EncryptionSupport: registry.EncryptionMetamorphic, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { c.Put(ctx, t.Cockroach(), "./cockroach") c.Put(ctx, t.DeprecatedWorkload(), "./workload") @@ -885,6 +898,8 @@ func registerBackup(r registry.Registry) { Cluster: r.MakeClusterSpec(3, spec.CPU(8)), Leases: registry.MetamorphicLeases, EncryptionSupport: registry.EncryptionMetamorphic, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE { t.Skip("uses gs://cockroach-fixtures; see https://github.com/cockroachdb/cockroach/issues/105968") diff --git a/pkg/cmd/roachtest/tests/backup_restore_roundtrip.go b/pkg/cmd/roachtest/tests/backup_restore_roundtrip.go index 72453ddd38e2..65c0fef91d0c 100644 --- a/pkg/cmd/roachtest/tests/backup_restore_roundtrip.go +++ b/pkg/cmd/roachtest/tests/backup_restore_roundtrip.go @@ -38,6 +38,8 @@ func registerBackupRestoreRoundTrip(r registry.Registry) { Timeout: 8 * time.Hour, Owner: registry.OwnerDisasterRecovery, Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), EncryptionSupport: registry.EncryptionMetamorphic, RequiresLicense: true, Run: backupRestoreRoundTrip, diff --git a/pkg/cmd/roachtest/tests/cancel.go b/pkg/cmd/roachtest/tests/cancel.go index 7719bd467583..e72ed262002c 100644 --- a/pkg/cmd/roachtest/tests/cancel.go +++ b/pkg/cmd/roachtest/tests/cancel.go @@ -178,20 +178,24 @@ func registerCancel(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: fmt.Sprintf("cancel/tpch/distsql/queries=%s,nodes=%d", queries, numNodes), - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("cancel/tpch/distsql/queries=%s,nodes=%d", queries, numNodes), + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCancel(ctx, t, c, tpchQueriesToRun, true /* useDistsql */) }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("cancel/tpch/local/queries=%s,nodes=%d", queries, numNodes), - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("cancel/tpch/local/queries=%s,nodes=%d", queries, numNodes), + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCancel(ctx, t, c, tpchQueriesToRun, false /* useDistsql */) }, diff --git a/pkg/cmd/roachtest/tests/cdc.go b/pkg/cmd/roachtest/tests/cdc.go index d4c205d69f09..31c6a7eaf39f 100644 --- a/pkg/cmd/roachtest/tests/cdc.go +++ b/pkg/cmd/roachtest/tests/cdc.go @@ -961,11 +961,13 @@ func skipLocalUnderArm64(cloud string) string { func registerCDC(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "cdc/initial-scan-only", - Owner: registry.OwnerCDC, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16), spec.Arch(vm.ArchAMD64)), - RequiresLicense: true, + Name: "cdc/initial-scan-only", + Owner: registry.OwnerCDC, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16), spec.Arch(vm.ArchAMD64)), + RequiresLicense: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -986,12 +988,14 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/tpcc-1000", - Owner: registry.OwnerCDC, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/tpcc-1000", + Owner: registry.OwnerCDC, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + RequiresLicense: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1011,13 +1015,16 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/tpcc-1000/sink=null", - Owner: registry.OwnerCDC, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags("manual"), - RequiresLicense: true, + Name: "cdc/tpcc-1000/sink=null", + Owner: registry.OwnerCDC, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + // TODO(radu): fix this. + CompatibleClouds: registry.AllClouds, + Suites: registry.ManualOnly, + Tags: registry.Tags("manual"), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1037,12 +1044,14 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/initial-scan", - Owner: registry.OwnerCDC, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/initial-scan", + Owner: registry.OwnerCDC, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1058,12 +1067,14 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/sink-chaos", - Owner: `cdc`, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/sink-chaos", + Owner: `cdc`, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1084,12 +1095,14 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/crdb-chaos", - Owner: `cdc`, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/crdb-chaos", + Owner: `cdc`, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1117,10 +1130,12 @@ func registerCDC(r registry.Registry) { // TODO(mrtracy): This workload is designed to be running on a 20CPU nodes, // but this cannot be allocated without some sort of configuration outside // of this test. Look into it. - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1148,12 +1163,14 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/cloud-sink-gcs/rangefeed=true", - Owner: `cdc`, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/cloud-sink-gcs/rangefeed=true", + Owner: `cdc`, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1176,12 +1193,14 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/pubsub-sink", - Owner: `cdc`, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/pubsub-sink", + Owner: `cdc`, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1213,12 +1232,14 @@ func registerCDC(r registry.Registry) { // TODO(rui): Change to a shorter test as it just needs to validate // permissions and shouldn't need to run a full 30m workload. r.Add(registry.TestSpec{ - Name: "cdc/pubsub-sink/assume-role", - Owner: `cdc`, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/pubsub-sink/assume-role", + Owner: `cdc`, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1247,12 +1268,14 @@ func registerCDC(r registry.Registry) { // TODO(rui): Change to a shorter test as it just needs to validate // permissions and shouldn't need to run a full 30m workload. r.Add(registry.TestSpec{ - Name: "cdc/cloud-sink-gcs/assume-role", - Owner: `cdc`, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/cloud-sink-gcs/assume-role", + Owner: `cdc`, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1272,12 +1295,14 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/webhook-sink", - Owner: `cdc`, - Benchmark: true, - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/webhook-sink", + Owner: `cdc`, + Benchmark: true, + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1313,11 +1338,13 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/kafka-auth", - Owner: `cdc`, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/kafka-auth", + Owner: `cdc`, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCDCKafkaAuth(ctx, t, c) }, @@ -1327,10 +1354,12 @@ func registerCDC(r registry.Registry) { Owner: `cdc`, Benchmark: true, // Only Kafka 3 supports Arm64, but the broker setup for Oauth used only works with Kafka 2 - Skip: skipLocalUnderArm64(r.Cloud()), - Cluster: r.MakeClusterSpec(4, spec.Arch(vm.ArchAMD64)), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Skip: skipLocalUnderArm64(r.Cloud()), + Cluster: r.MakeClusterSpec(4, spec.Arch(vm.ArchAMD64)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { ct := newCDCTester(ctx, t, c) defer ct.Close() @@ -1365,22 +1394,26 @@ func registerCDC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "cdc/bank", - Owner: `cdc`, - Cluster: r.MakeClusterSpec(4), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, - Timeout: 30 * time.Minute, + Name: "cdc/bank", + Owner: `cdc`, + Cluster: r.MakeClusterSpec(4), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, + Timeout: 30 * time.Minute, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCDCBank(ctx, t, c) }, }) r.Add(registry.TestSpec{ - Name: "cdc/schemareg", - Owner: `cdc`, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - RequiresLicense: true, + Name: "cdc/schemareg", + Owner: `cdc`, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCDCSchemaRegistry(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/clearrange.go b/pkg/cmd/roachtest/tests/clearrange.go index da1647b91133..97bb02ccba6a 100644 --- a/pkg/cmd/roachtest/tests/clearrange.go +++ b/pkg/cmd/roachtest/tests/clearrange.go @@ -35,9 +35,12 @@ func registerClearRange(r registry.Registry) { Owner: registry.OwnerStorage, // 5h for import, 90 for the test. The import should take closer // to <3:30h but it varies. - Timeout: 5*time.Hour + 90*time.Minute, - Cluster: r.MakeClusterSpec(10, spec.CPU(16)), - Leases: registry.MetamorphicLeases, + Timeout: 5*time.Hour + 90*time.Minute, + Cluster: r.MakeClusterSpec(10, spec.CPU(16)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runClearRange(ctx, t, c, checks, rangeTombstones) }, @@ -54,6 +57,8 @@ func registerClearRange(r registry.Registry) { // to <3:30h but it varies. Timeout: 5*time.Hour + 120*time.Minute, Cluster: r.MakeClusterSpec(10, spec.CPU(16), spec.SetFileSystem(spec.Zfs)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { diff --git a/pkg/cmd/roachtest/tests/clock_jump_crash.go b/pkg/cmd/roachtest/tests/clock_jump_crash.go index 341edd3a1d09..17e930644ddc 100644 --- a/pkg/cmd/roachtest/tests/clock_jump_crash.go +++ b/pkg/cmd/roachtest/tests/clock_jump_crash.go @@ -138,8 +138,10 @@ func registerClockJumpTests(r registry.Registry) { Owner: registry.OwnerKV, // These tests muck with NTP, therefore we don't want the cluster reused // by others. - Cluster: r.MakeClusterSpec(1, spec.ReuseTagged("offset-injector"), spec.TerminateOnMigration()), - Leases: registry.MetamorphicLeases, + Cluster: r.MakeClusterSpec(1, spec.ReuseTagged("offset-injector"), spec.TerminateOnMigration()), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runClockJump(ctx, t, c, tc) }, diff --git a/pkg/cmd/roachtest/tests/clock_monotonic.go b/pkg/cmd/roachtest/tests/clock_monotonic.go index 469dda8032d8..b065a008452b 100644 --- a/pkg/cmd/roachtest/tests/clock_monotonic.go +++ b/pkg/cmd/roachtest/tests/clock_monotonic.go @@ -140,8 +140,10 @@ func registerClockMonotonicTests(r registry.Registry) { Owner: registry.OwnerKV, // These tests muck with NTP, therefor we don't want the cluster reused by // others. - Cluster: r.MakeClusterSpec(1, spec.ReuseTagged("offset-injector"), spec.TerminateOnMigration()), - Leases: registry.MetamorphicLeases, + Cluster: r.MakeClusterSpec(1, spec.ReuseTagged("offset-injector"), spec.TerminateOnMigration()), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runClockMonotonicity(ctx, t, c, tc) }, diff --git a/pkg/cmd/roachtest/tests/cluster_to_cluster.go b/pkg/cmd/roachtest/tests/cluster_to_cluster.go index a29bd480636a..eaf8f3768e28 100644 --- a/pkg/cmd/roachtest/tests/cluster_to_cluster.go +++ b/pkg/cmd/roachtest/tests/cluster_to_cluster.go @@ -332,6 +332,8 @@ type replicationSpec struct { // If non-empty, the test will be skipped with the supplied reason. skip string + clouds registry.CloudSet + suites registry.SuiteSet // tags are used to categorize the test. tags map[string]struct{} } @@ -747,16 +749,18 @@ func c2cRegisterWrapper( } r.Add(registry.TestSpec{ - Name: sp.name, - Owner: registry.OwnerDisasterRecovery, - Benchmark: sp.benchmark, - Cluster: r.MakeClusterSpec(sp.dstNodes+sp.srcNodes+1, clusterOps...), - Leases: registry.MetamorphicLeases, - Timeout: sp.timeout, - Skip: sp.skip, - Tags: sp.tags, - RequiresLicense: true, - Run: run, + Name: sp.name, + Owner: registry.OwnerDisasterRecovery, + Benchmark: sp.benchmark, + Cluster: r.MakeClusterSpec(sp.dstNodes+sp.srcNodes+1, clusterOps...), + Leases: registry.MetamorphicLeases, + Timeout: sp.timeout, + Skip: sp.skip, + CompatibleClouds: sp.clouds, + Suites: sp.suites, + Tags: sp.tags, + RequiresLicense: true, + Run: run, }) } @@ -772,6 +776,8 @@ func runAcceptanceClusterReplication(ctx context.Context, t test.Test, c cluster workload: replicateKV{readPercent: 0, debugRunDuration: 1 * time.Minute, maxBlockBytes: 1}, additionalDuration: 0 * time.Minute, cutover: 30 * time.Second, + clouds: registry.AllExceptAWS, + suites: registry.Suites("nightly"), } rd := makeReplicationDriver(t, c, sp) rd.setupC2C(ctx, t, c) @@ -801,6 +807,8 @@ func registerClusterToCluster(r registry.Registry) { workload: replicateTPCC{warehouses: 500}, timeout: 1 * time.Hour, additionalDuration: 10 * time.Minute, + clouds: registry.AllExceptAWS, + suites: registry.Suites("nightly"), cutover: 5 * time.Minute, }, { @@ -818,6 +826,8 @@ func registerClusterToCluster(r registry.Registry) { timeout: 3 * time.Hour, additionalDuration: 60 * time.Minute, cutover: 30 * time.Minute, + clouds: registry.AllExceptAWS, + suites: registry.Suites("nightly"), }, { name: "c2c/kv0", @@ -831,6 +841,8 @@ func registerClusterToCluster(r registry.Registry) { additionalDuration: 10 * time.Minute, cutover: 5 * time.Minute, tags: registry.Tags("aws"), + clouds: registry.AllClouds, + suites: registry.Suites("nightly"), }, { name: "c2c/UnitTest", @@ -843,7 +855,8 @@ func registerClusterToCluster(r registry.Registry) { timeout: 5 * time.Minute, additionalDuration: 0 * time.Minute, cutover: 30 * time.Second, - skip: "for local ad hoc testing", + clouds: registry.AllExceptAWS, + suites: registry.Suites("nightly"), }, { name: "c2c/BulkOps", @@ -855,6 +868,8 @@ func registerClusterToCluster(r registry.Registry) { timeout: 4 * time.Hour, additionalDuration: 0, cutover: 5 * time.Minute, + clouds: registry.AllExceptAWS, + suites: registry.Suites("nightly"), skip: "flaky", }, } { @@ -1124,6 +1139,8 @@ func registerClusterReplicationResilience(r registry.Registry) { additionalDuration: 6 * time.Minute, cutover: 3 * time.Minute, expectedNodeDeaths: 1, + clouds: registry.AllExceptAWS, + suites: registry.Suites("nightly"), } c2cRegisterWrapper(r, rsp.replicationSpec, @@ -1227,6 +1244,8 @@ func registerClusterReplicationDisconnect(r registry.Registry) { additionalDuration: 10 * time.Minute, cutover: 2 * time.Minute, maxAcceptedLatency: 12 * time.Minute, + clouds: registry.AllExceptAWS, + suites: registry.Suites("nightly"), } c2cRegisterWrapper(r, sp, func(ctx context.Context, t test.Test, c cluster.Cluster) { rd := makeReplicationDriver(t, c, sp) diff --git a/pkg/cmd/roachtest/tests/connection_latency.go b/pkg/cmd/roachtest/tests/connection_latency.go index a7a01ff34115..a6899189770e 100644 --- a/pkg/cmd/roachtest/tests/connection_latency.go +++ b/pkg/cmd/roachtest/tests/connection_latency.go @@ -122,7 +122,9 @@ func registerConnectionLatencyTest(r registry.Registry) { Owner: registry.OwnerSQLFoundations, Benchmark: true, // Add one more node for load node. - Cluster: r.MakeClusterSpec(numNodes+1, spec.Zones(regionUsCentral)), + Cluster: r.MakeClusterSpec(numNodes+1, spec.Zones(regionUsCentral)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runConnectionLatencyTest(ctx, t, c, numNodes, 1, false /*password*/) }, @@ -135,20 +137,24 @@ func registerConnectionLatencyTest(r registry.Registry) { loadNodes := numZones r.Add(registry.TestSpec{ - Name: fmt.Sprintf("connection_latency/nodes=%d/multiregion/certs", numMultiRegionNodes), - Owner: registry.OwnerSQLFoundations, - Benchmark: true, - Cluster: r.MakeClusterSpec(numMultiRegionNodes+loadNodes, spec.Geo(), spec.Zones(geoZonesStr)), + Name: fmt.Sprintf("connection_latency/nodes=%d/multiregion/certs", numMultiRegionNodes), + Owner: registry.OwnerSQLFoundations, + Benchmark: true, + Cluster: r.MakeClusterSpec(numMultiRegionNodes+loadNodes, spec.Geo(), spec.Zones(geoZonesStr)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runConnectionLatencyTest(ctx, t, c, numMultiRegionNodes, numZones, false /*password*/) }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("connection_latency/nodes=%d/multiregion/password", numMultiRegionNodes), - Owner: registry.OwnerSQLFoundations, - Benchmark: true, - Cluster: r.MakeClusterSpec(numMultiRegionNodes+loadNodes, spec.Geo(), spec.Zones(geoZonesStr)), + Name: fmt.Sprintf("connection_latency/nodes=%d/multiregion/password", numMultiRegionNodes), + Owner: registry.OwnerSQLFoundations, + Benchmark: true, + Cluster: r.MakeClusterSpec(numMultiRegionNodes+loadNodes, spec.Geo(), spec.Zones(geoZonesStr)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runConnectionLatencyTest(ctx, t, c, numMultiRegionNodes, numZones, true /*password*/) }, diff --git a/pkg/cmd/roachtest/tests/copy.go b/pkg/cmd/roachtest/tests/copy.go index 06cedc1e48f9..50555d09df02 100644 --- a/pkg/cmd/roachtest/tests/copy.go +++ b/pkg/cmd/roachtest/tests/copy.go @@ -180,10 +180,12 @@ func registerCopy(r registry.Registry) { for _, tc := range testcases { tc := tc r.Add(registry.TestSpec{ - Name: fmt.Sprintf("copy/bank/rows=%d,nodes=%d,txn=%t", tc.rows, tc.nodes, tc.txn), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(tc.nodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("copy/bank/rows=%d,nodes=%d,txn=%t", tc.rows, tc.nodes, tc.txn), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(tc.nodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE { t.Skip("uses gs://cockroach-fixtures; see https://github.com/cockroachdb/cockroach/issues/105968") diff --git a/pkg/cmd/roachtest/tests/copyfrom.go b/pkg/cmd/roachtest/tests/copyfrom.go index fe83a2b0e496..110534b59b64 100644 --- a/pkg/cmd/roachtest/tests/copyfrom.go +++ b/pkg/cmd/roachtest/tests/copyfrom.go @@ -167,31 +167,37 @@ func registerCopyFrom(r registry.Registry) { for _, tc := range testcases { tc := tc r.Add(registry.TestSpec{ - Name: fmt.Sprintf("copyfrom/crdb-atomic/sf=%d/nodes=%d", tc.sf, tc.nodes), - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(tc.nodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("copyfrom/crdb-atomic/sf=%d/nodes=%d", tc.sf, tc.nodes), + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(tc.nodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCopyFromCRDB(ctx, t, c, tc.sf, true /*atomic*/) }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("copyfrom/crdb-nonatomic/sf=%d/nodes=%d", tc.sf, tc.nodes), - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(tc.nodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("copyfrom/crdb-nonatomic/sf=%d/nodes=%d", tc.sf, tc.nodes), + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(tc.nodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCopyFromCRDB(ctx, t, c, tc.sf, false /*atomic*/) }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("copyfrom/pg/sf=%d/nodes=%d", tc.sf, tc.nodes), - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(tc.nodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("copyfrom/pg/sf=%d/nodes=%d", tc.sf, tc.nodes), + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(tc.nodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCopyFromPG(ctx, t, c, tc.sf) }, diff --git a/pkg/cmd/roachtest/tests/costfuzz.go b/pkg/cmd/roachtest/tests/costfuzz.go index 4b82f0812b7c..6dbc80b5ee7c 100644 --- a/pkg/cmd/roachtest/tests/costfuzz.go +++ b/pkg/cmd/roachtest/tests/costfuzz.go @@ -36,14 +36,16 @@ func registerCostFuzz(r registry.Registry) { clusterSpec = r.MakeClusterSpec(1) } r.Add(registry.TestSpec{ - Name: fmt.Sprintf("costfuzz/%s", setupName), - Owner: registry.OwnerSQLQueries, - Timeout: time.Hour * 1, - RequiresLicense: true, - Tags: nil, - Cluster: clusterSpec, - Leases: registry.MetamorphicLeases, - NativeLibs: registry.LibGEOS, + Name: fmt.Sprintf("costfuzz/%s", setupName), + Owner: registry.OwnerSQLQueries, + Timeout: time.Hour * 1, + RequiresLicense: true, + Tags: nil, + Cluster: clusterSpec, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + NativeLibs: registry.LibGEOS, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runQueryComparison(ctx, t, c, &queryComparisonTest{ name: "costfuzz", setupName: setupName, run: runCostFuzzQuery, diff --git a/pkg/cmd/roachtest/tests/decommission.go b/pkg/cmd/roachtest/tests/decommission.go index b136b58859fd..b5d185485a73 100644 --- a/pkg/cmd/roachtest/tests/decommission.go +++ b/pkg/cmd/roachtest/tests/decommission.go @@ -43,10 +43,12 @@ func registerDecommission(r registry.Registry) { duration := time.Hour r.Add(registry.TestSpec{ - Name: fmt.Sprintf("decommission/nodes=%d/duration=%s", numNodes, duration), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("decommission/nodes=%d/duration=%s", numNodes, duration), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.IsLocal() { duration = 5 * time.Minute @@ -60,10 +62,12 @@ func registerDecommission(r registry.Registry) { numNodes := 9 duration := 30 * time.Minute r.Add(registry.TestSpec{ - Name: fmt.Sprintf("drain-and-decommission/nodes=%d", numNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("drain-and-decommission/nodes=%d", numNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runDrainAndDecommission(ctx, t, c, numNodes, duration) }, @@ -72,10 +76,12 @@ func registerDecommission(r registry.Registry) { { numNodes := 4 r.Add(registry.TestSpec{ - Name: "decommission/drains", - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: "decommission/drains", + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runDecommissionDrains(ctx, t, c) }, @@ -84,11 +90,13 @@ func registerDecommission(r registry.Registry) { { numNodes := 6 r.Add(registry.TestSpec{ - Name: "decommission/randomized", - Owner: registry.OwnerKV, - Timeout: 10 * time.Minute, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: "decommission/randomized", + Owner: registry.OwnerKV, + Timeout: 10 * time.Minute, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runDecommissionRandomized(ctx, t, c) }, @@ -97,9 +105,11 @@ func registerDecommission(r registry.Registry) { { numNodes := 4 r.Add(registry.TestSpec{ - Name: "decommission/mixed-versions", - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), + Name: "decommission/mixed-versions", + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runDecommissionMixedVersions(ctx, t, c, t.BuildVersion()) }, @@ -108,10 +118,12 @@ func registerDecommission(r registry.Registry) { { numNodes := 6 r.Add(registry.TestSpec{ - Name: "decommission/slow", - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: "decommission/slow", + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runDecommissionSlow(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/decommissionbench.go b/pkg/cmd/roachtest/tests/decommissionbench.go index 4eb25dd1fdba..9851964aca46 100644 --- a/pkg/cmd/roachtest/tests/decommissionbench.go +++ b/pkg/cmd/roachtest/tests/decommissionbench.go @@ -293,6 +293,8 @@ func registerDecommissionBenchSpec(r registry.Registry, benchSpec decommissionBe benchSpec.nodes+addlNodeCount+1, specOptions..., ), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), SkipPostValidations: registry.PostValidationNoDeadNodes, Timeout: timeout, NonReleaseBlocker: true, diff --git a/pkg/cmd/roachtest/tests/disk_full.go b/pkg/cmd/roachtest/tests/disk_full.go index 4c3377acc15b..66175a945708 100644 --- a/pkg/cmd/roachtest/tests/disk_full.go +++ b/pkg/cmd/roachtest/tests/disk_full.go @@ -27,10 +27,12 @@ import ( func registerDiskFull(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "disk-full", - Owner: registry.OwnerStorage, - Cluster: r.MakeClusterSpec(5), - Leases: registry.MetamorphicLeases, + Name: "disk-full", + Owner: registry.OwnerStorage, + Cluster: r.MakeClusterSpec(5), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.IsLocal() { t.Skip("you probably don't want to fill your local disk") diff --git a/pkg/cmd/roachtest/tests/disk_stall.go b/pkg/cmd/roachtest/tests/disk_stall.go index 4011077024a1..8aff11089a18 100644 --- a/pkg/cmd/roachtest/tests/disk_stall.go +++ b/pkg/cmd/roachtest/tests/disk_stall.go @@ -61,6 +61,8 @@ func registerDiskStalledDetection(r registry.Registry) { Name: fmt.Sprintf("disk-stalled/%s", name), Owner: registry.OwnerStorage, Cluster: makeSpec(), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Timeout: 30 * time.Minute, SkipPostValidations: registry.PostValidationNoDeadNodes, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { diff --git a/pkg/cmd/roachtest/tests/django.go b/pkg/cmd/roachtest/tests/django.go index 02d36c0e875b..0a061c885248 100644 --- a/pkg/cmd/roachtest/tests/django.go +++ b/pkg/cmd/roachtest/tests/django.go @@ -214,11 +214,13 @@ func registerDjango(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "django", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `orm`), + Name: "django", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runDjango(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/drain.go b/pkg/cmd/roachtest/tests/drain.go index 6fe504a3fa43..a8cf871e8a0c 100644 --- a/pkg/cmd/roachtest/tests/drain.go +++ b/pkg/cmd/roachtest/tests/drain.go @@ -37,20 +37,24 @@ import ( func registerDrain(r registry.Registry) { { r.Add(registry.TestSpec{ - Name: "drain/early-exit-conn-wait", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, + Name: "drain/early-exit-conn-wait", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runEarlyExitInConnectionWait(ctx, t, c) }, }) r.Add(registry.TestSpec{ - Name: "drain/warn-conn-wait-timeout", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, + Name: "drain/warn-conn-wait-timeout", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runWarningForConnWait(ctx, t, c) }, @@ -60,6 +64,8 @@ func registerDrain(r registry.Registry) { Name: "drain/not-at-quorum", Owner: registry.OwnerSQLFoundations, Cluster: r.MakeClusterSpec(3), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), SkipPostValidations: registry.PostValidationNoDeadNodes, Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { diff --git a/pkg/cmd/roachtest/tests/drop.go b/pkg/cmd/roachtest/tests/drop.go index 7945ccdd1375..0cd4ca1f8fe3 100644 --- a/pkg/cmd/roachtest/tests/drop.go +++ b/pkg/cmd/roachtest/tests/drop.go @@ -162,10 +162,12 @@ func registerDrop(r registry.Registry) { numNodes := 9 r.Add(registry.TestSpec{ - Name: fmt.Sprintf("drop/tpcc/w=%d,nodes=%d", warehouses, numNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("drop/tpcc/w=%d,nodes=%d", warehouses, numNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { // NB: this is likely not going to work out in `-local` mode. Edit the // numbers during iteration. diff --git a/pkg/cmd/roachtest/tests/encryption.go b/pkg/cmd/roachtest/tests/encryption.go index 460622cf2bde..5021974afc96 100644 --- a/pkg/cmd/roachtest/tests/encryption.go +++ b/pkg/cmd/roachtest/tests/encryption.go @@ -89,6 +89,8 @@ func registerEncryption(r registry.Registry) { Leases: registry.MetamorphicLeases, Owner: registry.OwnerStorage, Cluster: r.MakeClusterSpec(n), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runEncryption(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/failover.go b/pkg/cmd/roachtest/tests/failover.go index 8093fb3a0219..ba726033710d 100644 --- a/pkg/cmd/roachtest/tests/failover.go +++ b/pkg/cmd/roachtest/tests/failover.go @@ -77,6 +77,8 @@ func registerFailover(r registry.Registry) { Owner: registry.OwnerKV, Timeout: 60 * time.Minute, Cluster: r.MakeClusterSpec(10, spec.CPU(2), spec.PreferLocalSSD(false), spec.ReuseNone()), // uses disk stalls + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Leases: leases, SkipPostValidations: registry.PostValidationNoDeadNodes, // cleanup kills nodes Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -86,33 +88,39 @@ func registerFailover(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "failover/partial/lease-gateway" + suffix, - Owner: registry.OwnerKV, - Benchmark: true, - Timeout: 30 * time.Minute, - Cluster: r.MakeClusterSpec(8, spec.CPU(2)), - Leases: leases, - Run: runFailoverPartialLeaseGateway, + Name: "failover/partial/lease-gateway" + suffix, + Owner: registry.OwnerKV, + Benchmark: true, + Timeout: 30 * time.Minute, + Cluster: r.MakeClusterSpec(8, spec.CPU(2)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: leases, + Run: runFailoverPartialLeaseGateway, }) r.Add(registry.TestSpec{ - Name: "failover/partial/lease-leader" + suffix, - Owner: registry.OwnerKV, - Benchmark: true, - Timeout: 30 * time.Minute, - Cluster: r.MakeClusterSpec(7, spec.CPU(2)), - Leases: leases, - Run: runFailoverPartialLeaseLeader, + Name: "failover/partial/lease-leader" + suffix, + Owner: registry.OwnerKV, + Benchmark: true, + Timeout: 30 * time.Minute, + Cluster: r.MakeClusterSpec(7, spec.CPU(2)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: leases, + Run: runFailoverPartialLeaseLeader, }) r.Add(registry.TestSpec{ - Name: "failover/partial/lease-liveness" + suffix, - Owner: registry.OwnerKV, - Benchmark: true, - Timeout: 30 * time.Minute, - Cluster: r.MakeClusterSpec(8, spec.CPU(2)), - Leases: leases, - Run: runFailoverPartialLeaseLiveness, + Name: "failover/partial/lease-liveness" + suffix, + Owner: registry.OwnerKV, + Benchmark: true, + Timeout: 30 * time.Minute, + Cluster: r.MakeClusterSpec(8, spec.CPU(2)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: leases, + Run: runFailoverPartialLeaseLiveness, }) for _, failureMode := range allFailureModes { @@ -137,6 +145,8 @@ func registerFailover(r registry.Registry) { Benchmark: true, Timeout: 30 * time.Minute, Cluster: r.MakeClusterSpec(7, clusterOpts...), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Leases: leases, SkipPostValidations: postValidation, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -146,6 +156,8 @@ func registerFailover(r registry.Registry) { r.Add(registry.TestSpec{ Name: fmt.Sprintf("failover/liveness/%s%s", failureMode, suffix), Owner: registry.OwnerKV, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), Tags: registry.Tags("weekly"), Benchmark: true, Timeout: 30 * time.Minute, @@ -159,6 +171,8 @@ func registerFailover(r registry.Registry) { r.Add(registry.TestSpec{ Name: fmt.Sprintf("failover/system-non-liveness/%s%s", failureMode, suffix), Owner: registry.OwnerKV, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), Tags: registry.Tags("weekly"), Benchmark: true, Timeout: 30 * time.Minute, diff --git a/pkg/cmd/roachtest/tests/fixtures.go b/pkg/cmd/roachtest/tests/fixtures.go index 0abbc31842f4..667f98de6c3d 100644 --- a/pkg/cmd/roachtest/tests/fixtures.go +++ b/pkg/cmd/roachtest/tests/fixtures.go @@ -63,12 +63,14 @@ func registerFixtures(r registry.Registry) { makeVersionFixtureAndFatal(ctx, t, c, fixtureVersion) } spec := registry.TestSpec{ - Name: "generate-fixtures", - Timeout: 30 * time.Minute, - Tags: registry.Tags("fixtures"), - Owner: registry.OwnerDevInf, - Cluster: r.MakeClusterSpec(4), - Run: runFixtures, + Name: "generate-fixtures", + Timeout: 30 * time.Minute, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Fixtures), + Tags: registry.Tags("fixtures"), + Owner: registry.OwnerDevInf, + Cluster: r.MakeClusterSpec(4), + Run: runFixtures, } r.Add(spec) } diff --git a/pkg/cmd/roachtest/tests/flowable.go b/pkg/cmd/roachtest/tests/flowable.go index db934e5269bc..6b5a734695a7 100644 --- a/pkg/cmd/roachtest/tests/flowable.go +++ b/pkg/cmd/roachtest/tests/flowable.go @@ -146,10 +146,12 @@ grep "force-commit" . -lr | xargs sed -i 's/-- force-commit//g'`, } r.Add(registry.TestSpec{ - Name: "flowable", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, + Name: "flowable", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runFlowable(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/follower_reads.go b/pkg/cmd/roachtest/tests/follower_reads.go index a6a59b39256b..084e515a6762 100644 --- a/pkg/cmd/roachtest/tests/follower_reads.go +++ b/pkg/cmd/roachtest/tests/follower_reads.go @@ -64,7 +64,9 @@ func registerFollowerReads(r registry.Registry) { spec.Geo(), spec.Zones("us-east1-b,us-east1-b,us-east1-b,us-west1-b,us-west1-b,europe-west2-b"), ), - Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud == spec.GCE && c.Spec().Arch == vm.ArchARM64 { t.Skip("arm64 in GCE is available only in us-central1") @@ -106,6 +108,8 @@ func registerFollowerReads(r registry.Registry) { 3, /* nodeCount */ spec.CPU(2), ), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runFollowerReadsMixedVersionSingleRegionTest(ctx, t, c, t.BuildVersion()) }, diff --git a/pkg/cmd/roachtest/tests/gopg.go b/pkg/cmd/roachtest/tests/gopg.go index 5e5fef6a042e..2e0da5bbaf8f 100644 --- a/pkg/cmd/roachtest/tests/gopg.go +++ b/pkg/cmd/roachtest/tests/gopg.go @@ -155,11 +155,13 @@ func registerGopg(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "gopg", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Tags: registry.Tags(`default`, `orm`), - Leases: registry.MetamorphicLeases, + Name: "gopg", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runGopg(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/gorm.go b/pkg/cmd/roachtest/tests/gorm.go index 4e6b7d1a2a71..ae942c6be3f7 100644 --- a/pkg/cmd/roachtest/tests/gorm.go +++ b/pkg/cmd/roachtest/tests/gorm.go @@ -133,11 +133,13 @@ func registerGORM(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "gorm", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `orm`), - Run: runGORM, + Name: "gorm", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), + Run: runGORM, }) } diff --git a/pkg/cmd/roachtest/tests/gossip.go b/pkg/cmd/roachtest/tests/gossip.go index ccba2eb08246..d45e8a06f89b 100644 --- a/pkg/cmd/roachtest/tests/gossip.go +++ b/pkg/cmd/roachtest/tests/gossip.go @@ -141,10 +141,12 @@ SELECT node_id } r.Add(registry.TestSpec{ - Name: "gossip/chaos/nodes=9", - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(9), - Leases: registry.MetamorphicLeases, + Name: "gossip/chaos/nodes=9", + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(9), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runGossipChaos(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/hibernate.go b/pkg/cmd/roachtest/tests/hibernate.go index 176881576ef2..a81503cf4804 100644 --- a/pkg/cmd/roachtest/tests/hibernate.go +++ b/pkg/cmd/roachtest/tests/hibernate.go @@ -243,12 +243,14 @@ func registerHibernate(r registry.Registry, opt hibernateOptions) { } r.Add(registry.TestSpec{ - Name: opt.testName, - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - NativeLibs: registry.LibGEOS, - Tags: registry.Tags(`default`, `orm`), + Name: opt.testName, + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + NativeLibs: registry.LibGEOS, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runHibernate(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/hotspotsplits.go b/pkg/cmd/roachtest/tests/hotspotsplits.go index 97dcef05a67f..0abf210875cc 100644 --- a/pkg/cmd/roachtest/tests/hotspotsplits.go +++ b/pkg/cmd/roachtest/tests/hotspotsplits.go @@ -98,8 +98,10 @@ func registerHotSpotSplits(r registry.Registry) { // Test OOMs below this version because of scans over the large rows. // No problem in 20.1 thanks to: // https://github.com/cockroachdb/cockroach/pull/45323. - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.IsLocal() { concurrency = 32 diff --git a/pkg/cmd/roachtest/tests/import.go b/pkg/cmd/roachtest/tests/import.go index 13529111a300..ee8045680fa9 100644 --- a/pkg/cmd/roachtest/tests/import.go +++ b/pkg/cmd/roachtest/tests/import.go @@ -87,10 +87,12 @@ func registerImportNodeShutdown(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "import/nodeShutdown/worker", - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(4), - Leases: registry.MetamorphicLeases, + Name: "import/nodeShutdown/worker", + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE { t.Skip("uses gs://cockroach-fixtures; see https://github.com/cockroachdb/cockroach/issues/105968") @@ -105,10 +107,12 @@ func registerImportNodeShutdown(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "import/nodeShutdown/coordinator", - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(4), - Leases: registry.MetamorphicLeases, + Name: "import/nodeShutdown/coordinator", + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE { t.Skip("uses gs://cockroach-fixtures; see https://github.com/cockroachdb/cockroach/issues/105968") @@ -176,6 +180,8 @@ func registerImportTPCC(r registry.Registry) { Owner: registry.OwnerSQLQueries, Benchmark: true, Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Timeout: timeout, EncryptionSupport: registry.EncryptionMetamorphic, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -189,6 +195,8 @@ func registerImportTPCC(r registry.Registry) { Name: fmt.Sprintf("import/tpcc/warehouses=%d/geo", geoWarehouses), Owner: registry.OwnerSQLQueries, Cluster: r.MakeClusterSpec(8, spec.CPU(16), spec.Geo(), spec.Zones(geoZones)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Timeout: 5 * time.Hour, EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, @@ -223,6 +231,8 @@ func registerImportTPCH(r registry.Registry) { Owner: registry.OwnerSQLQueries, Benchmark: true, Cluster: r.MakeClusterSpec(item.nodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Timeout: item.timeout, EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, @@ -367,7 +377,9 @@ func registerImportMixedVersion(r registry.Registry) { Name: "import/mixed-versions", Owner: registry.OwnerSQLQueries, // Mixed-version support was added in 21.1. - Cluster: r.MakeClusterSpec(4), + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { predV, err := release.LatestPredecessor(t.BuildVersion()) if err != nil { @@ -408,10 +420,12 @@ func registerImportDecommissioned(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "import/decommissioned", - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(4), - Leases: registry.MetamorphicLeases, - Run: runImportDecommissioned, + Name: "import/decommissioned", + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Run: runImportDecommissioned, }) } diff --git a/pkg/cmd/roachtest/tests/import_cancellation.go b/pkg/cmd/roachtest/tests/import_cancellation.go index 6537468c8421..1fce4015a9e2 100644 --- a/pkg/cmd/roachtest/tests/import_cancellation.go +++ b/pkg/cmd/roachtest/tests/import_cancellation.go @@ -29,14 +29,17 @@ import ( ) func registerImportCancellation(r registry.Registry) { + for _, rangeTombstones := range []bool{true, false} { r.Add(registry.TestSpec{ - Name: fmt.Sprintf(`import-cancellation/rangeTs=%t`, rangeTombstones), - Owner: registry.OwnerDisasterRecovery, - Benchmark: true, - Timeout: 4 * time.Hour, - Cluster: r.MakeClusterSpec(6, spec.CPU(32)), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf(`import-cancellation/rangeTs=%t`, rangeTombstones), + Owner: registry.OwnerDisasterRecovery, + Benchmark: true, + Timeout: 4 * time.Hour, + Cluster: r.MakeClusterSpec(6, spec.CPU(32)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE { t.Skip("uses gs://cockroach-fixtures; see https://github.com/cockroachdb/cockroach/issues/105968") diff --git a/pkg/cmd/roachtest/tests/inconsistency.go b/pkg/cmd/roachtest/tests/inconsistency.go index 2266889f1375..2d1677d01936 100644 --- a/pkg/cmd/roachtest/tests/inconsistency.go +++ b/pkg/cmd/roachtest/tests/inconsistency.go @@ -24,11 +24,13 @@ import ( func registerInconsistency(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "inconsistency", - Owner: registry.OwnerReplication, - Cluster: r.MakeClusterSpec(3), - Leases: registry.MetamorphicLeases, - Run: runInconsistency, + Name: "inconsistency", + Owner: registry.OwnerReplication, + Cluster: r.MakeClusterSpec(3), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Run: runInconsistency, }) } diff --git a/pkg/cmd/roachtest/tests/indexes.go b/pkg/cmd/roachtest/tests/indexes.go index a3f3b0f02e69..2c42a8d98d9b 100644 --- a/pkg/cmd/roachtest/tests/indexes.go +++ b/pkg/cmd/roachtest/tests/indexes.go @@ -34,10 +34,12 @@ func registerNIndexes(r registry.Registry, secondaryIndexes int) { } geoZonesStr := strings.Join(geoZones, ",") r.Add(registry.TestSpec{ - Name: fmt.Sprintf("indexes/%d/nodes=%d/multi-region", secondaryIndexes, nodes), - Owner: registry.OwnerKV, - Benchmark: true, - Cluster: r.MakeClusterSpec(nodes+1, spec.CPU(16), spec.Geo(), spec.Zones(geoZonesStr)), + Name: fmt.Sprintf("indexes/%d/nodes=%d/multi-region", secondaryIndexes, nodes), + Owner: registry.OwnerKV, + Benchmark: true, + Cluster: r.MakeClusterSpec(nodes+1, spec.CPU(16), spec.Geo(), spec.Zones(geoZonesStr)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), // Uses CONFIGURE ZONE USING ... COPY FROM PARENT syntax. Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { firstAZ := geoZones[0] diff --git a/pkg/cmd/roachtest/tests/inverted_index.go b/pkg/cmd/roachtest/tests/inverted_index.go index a1946e055874..fbded79e7811 100644 --- a/pkg/cmd/roachtest/tests/inverted_index.go +++ b/pkg/cmd/roachtest/tests/inverted_index.go @@ -25,10 +25,12 @@ import ( func registerSchemaChangeInvertedIndex(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "schemachange/invertedindex", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(5), - Leases: registry.MetamorphicLeases, + Name: "schemachange/invertedindex", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(5), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runSchemaChangeInvertedIndex(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/jasyncsql.go b/pkg/cmd/roachtest/tests/jasyncsql.go index 27e79cc7b925..abf53a56c06b 100644 --- a/pkg/cmd/roachtest/tests/jasyncsql.go +++ b/pkg/cmd/roachtest/tests/jasyncsql.go @@ -140,11 +140,13 @@ func registerJasyncSQL(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "jasync", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `orm`), + Name: "jasync", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runJasyncSQL(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/jepsen.go b/pkg/cmd/roachtest/tests/jepsen.go index 039f20906600..109604cef3e9 100644 --- a/pkg/cmd/roachtest/tests/jepsen.go +++ b/pkg/cmd/roachtest/tests/jepsen.go @@ -490,8 +490,10 @@ func registerJepsen(r registry.Registry) { // clusters because they have a lengthy setup step, but avoid doing it // if they detect that the machines have already been properly // initialized. - Cluster: r.MakeClusterSpec(6, spec.ReuseTagged("jepsen")), - Leases: registry.MetamorphicLeases, + Cluster: r.MakeClusterSpec(6, spec.ReuseTagged("jepsen")), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runJepsen(ctx, t, c, testName, nemesis.config) }, diff --git a/pkg/cmd/roachtest/tests/knex.go b/pkg/cmd/roachtest/tests/knex.go index c17d27d2dd7c..4dfdeb9c23ef 100644 --- a/pkg/cmd/roachtest/tests/knex.go +++ b/pkg/cmd/roachtest/tests/knex.go @@ -127,12 +127,14 @@ func registerKnex(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "knex", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - NativeLibs: registry.LibGEOS, - Tags: registry.Tags(`default`, `orm`), + Name: "knex", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + NativeLibs: registry.LibGEOS, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runKnex(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/kv.go b/pkg/cmd/roachtest/tests/kv.go index 0548c1995e92..d2357e7f5d33 100644 --- a/pkg/cmd/roachtest/tests/kv.go +++ b/pkg/cmd/roachtest/tests/kv.go @@ -63,7 +63,7 @@ func registerKV(r registry.Registry) { raid0 bool duration time.Duration tracing bool // `trace.debug.enable` - tags map[string]struct{} + weekly bool owner registry.Owner // defaults to KV } computeNumSplits := func(opts kvOptions) int { @@ -239,8 +239,8 @@ func registerKV(r registry.Registry) { {nodes: 1, cpus: 32, readPercent: 95, spanReads: true, splits: -1 /* no splits */, disableLoadSplits: true, sequential: true}, // Weekly larger scale configurations. - {nodes: 32, cpus: 8, readPercent: 0, tags: registry.Tags("weekly"), duration: time.Hour}, - {nodes: 32, cpus: 8, readPercent: 95, tags: registry.Tags("weekly"), duration: time.Hour}, + {nodes: 32, cpus: 8, readPercent: 0, weekly: true, duration: time.Hour}, + {nodes: 32, cpus: 8, readPercent: 95, weekly: true, duration: time.Hour}, } { opts := opts @@ -250,12 +250,8 @@ func registerKV(r registry.Registry) { limitedSpanStr = "limited-spans" } nameParts = append(nameParts, fmt.Sprintf("kv%d%s", opts.readPercent, limitedSpanStr)) - if len(opts.tags) > 0 { - var keys []string - for k := range opts.tags { - keys = append(keys, k) - } - nameParts = append(nameParts, strings.Join(keys, "/")) + if opts.weekly { + nameParts = append(nameParts, "weekly") } nameParts = append(nameParts, fmt.Sprintf("enc=%t", opts.encryption)) nameParts = append(nameParts, fmt.Sprintf("nodes=%d", opts.nodes)) @@ -302,9 +298,17 @@ func registerKV(r registry.Registry) { } cSpec := r.MakeClusterSpec(opts.nodes+1, spec.CPU(opts.cpus), spec.SSD(opts.ssds), spec.RAID0(opts.raid0)) + clouds := registry.AllExceptAWS + var tags map[string]struct{} // All the kv0|95 tests should run on AWS by default - if opts.tags == nil && opts.ssds == 0 && (opts.readPercent == 95 || opts.readPercent == 0) { - opts.tags = registry.Tags("aws") + if !opts.weekly && opts.ssds == 0 && (opts.readPercent == 95 || opts.readPercent == 0) { + clouds = registry.AllClouds + tags = registry.Tags("aws") + } + suites := registry.Suites(registry.Nightly) + if opts.weekly { + suites = registry.Suites(registry.Weekly) + tags = registry.Tags("weekly") } var skip string @@ -320,7 +324,9 @@ func registerKV(r registry.Registry) { Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runKV(ctx, t, c, opts) }, - Tags: opts.tags, + CompatibleClouds: clouds, + Suites: suites, + Tags: tags, EncryptionSupport: encryption, }) } @@ -329,11 +335,13 @@ func registerKV(r registry.Registry) { func registerKVContention(r registry.Registry) { const nodes = 4 r.Add(registry.TestSpec{ - Name: fmt.Sprintf("kv/contention/nodes=%d", nodes), - Owner: registry.OwnerKV, - Benchmark: true, - Cluster: r.MakeClusterSpec(nodes + 1), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("kv/contention/nodes=%d", nodes), + Owner: registry.OwnerKV, + Benchmark: true, + Cluster: r.MakeClusterSpec(nodes + 1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { c.Put(ctx, t.Cockroach(), "./cockroach", c.Range(1, nodes)) c.Put(ctx, t.DeprecatedWorkload(), "./workload", c.Node(nodes+1)) @@ -403,6 +411,8 @@ func registerKVQuiescenceDead(r registry.Registry) { Name: "kv/quiescence/nodes=3", Owner: registry.OwnerReplication, Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Leases: registry.EpochLeases, SkipPostValidations: registry.PostValidationNoDeadNodes, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -479,11 +489,13 @@ func registerKVQuiescenceDead(r registry.Registry) { func registerKVGracefulDraining(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "kv/gracefuldraining/nodes=3", - Owner: registry.OwnerKV, - Skip: "https://github.com/cockroachdb/cockroach/issues/59094", - Cluster: r.MakeClusterSpec(4), - Leases: registry.MetamorphicLeases, + Name: "kv/gracefuldraining/nodes=3", + Owner: registry.OwnerKV, + Skip: "https://github.com/cockroachdb/cockroach/issues/59094", + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { nodes := c.Spec().NodeCount - 1 c.Put(ctx, t.Cockroach(), "./cockroach", c.Range(1, nodes)) @@ -711,11 +723,13 @@ func registerKVSplits(r registry.Registry) { } { item := item // for use in closure below r.Add(registry.TestSpec{ - Name: fmt.Sprintf("kv/splits/nodes=3/quiesce=%t/lease=%s", item.quiesce, item.leases), - Owner: registry.OwnerKV, - Timeout: item.timeout, - Cluster: r.MakeClusterSpec(4), - Leases: item.leases, + Name: fmt.Sprintf("kv/splits/nodes=3/quiesce=%t/lease=%s", item.quiesce, item.leases), + Owner: registry.OwnerKV, + Timeout: item.timeout, + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: item.leases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { nodes := c.Spec().NodeCount - 1 c.Put(ctx, t.Cockroach(), "./cockroach", c.Range(1, nodes)) @@ -780,10 +794,12 @@ func registerKVScalability(r registry.Registry) { for _, p := range []int{0, 95} { p := p r.Add(registry.TestSpec{ - Name: fmt.Sprintf("kv%d/scale/nodes=6", p), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(7, spec.CPU(8)), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("kv%d/scale/nodes=6", p), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(7, spec.CPU(8)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runScalability(ctx, t, c, p) }, @@ -916,10 +932,12 @@ func registerKVRangeLookups(r registry.Registry) { panic("unexpected") } r.Add(registry.TestSpec{ - Name: fmt.Sprintf("kv50/rangelookups/%s/nodes=%d", workloadName, nodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(nodes+1, spec.CPU(cpus)), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("kv50/rangelookups/%s/nodes=%d", workloadName, nodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(nodes+1, spec.CPU(cpus)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runRangeLookups(ctx, t, c, item.workers, item.workloadType, item.maximumRangeLookupsPerSec) }, @@ -958,10 +976,12 @@ func registerKVRestartImpact(r registry.Registry) { r.Add(registry.TestSpec{ Name: "kv/restart/nodes=12", // This test is expensive (104vcpu), we run it weekly. - Tags: registry.Tags(`weekly`), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(13, spec.CPU(8)), - Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(13, spec.CPU(8)), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { nodes := c.Spec().NodeCount - 1 workloadNode := c.Spec().NodeCount diff --git a/pkg/cmd/roachtest/tests/kvbench.go b/pkg/cmd/roachtest/tests/kvbench.go index c90c52a51bcc..462ce6d2acc0 100644 --- a/pkg/cmd/roachtest/tests/kvbench.go +++ b/pkg/cmd/roachtest/tests/kvbench.go @@ -92,9 +92,11 @@ func registerKVBenchSpec(r registry.Registry, b kvBenchSpec) { // for --max-rate. // TODO(andrei): output something to roachperf and start running them // nightly. - Tags: registry.Tags("manual"), - Owner: registry.OwnerKV, - Cluster: nodes, + CompatibleClouds: registry.AllClouds, + Suites: registry.ManualOnly, + Tags: registry.Tags("manual"), + Owner: registry.OwnerKV, + Cluster: nodes, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runKVBench(ctx, t, c, b) }, diff --git a/pkg/cmd/roachtest/tests/lease_preferences.go b/pkg/cmd/roachtest/tests/lease_preferences.go index 1184ca79bf68..adedc146e31a 100644 --- a/pkg/cmd/roachtest/tests/lease_preferences.go +++ b/pkg/cmd/roachtest/tests/lease_preferences.go @@ -103,6 +103,8 @@ func registerLeasePreferences(r registry.Registry) { // validation. SkipPostValidations: registry.PostValidationNoDeadNodes, Cluster: r.MakeClusterSpec(5, spec.CPU(4)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLeasePreferences(ctx, t, c, leasePreferencesSpec{ preferences: `[+dc=1],[+dc=2]`, @@ -127,6 +129,8 @@ func registerLeasePreferences(r registry.Registry) { // validation. SkipPostValidations: registry.PostValidationNoDeadNodes, Cluster: r.MakeClusterSpec(5, spec.CPU(4)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLeasePreferences(ctx, t, c, leasePreferencesSpec{ preferences: `[+dc=1],[+dc=2]`, @@ -143,10 +147,12 @@ func registerLeasePreferences(r registry.Registry) { // NB: This test manually transfers leases onto [+dc=3], which violates the // lease preferences. This test then waits until all the leases are back on // the most preferred locality. - Name: "lease-preferences/manual-violating-transfer", - Owner: registry.OwnerKV, - Timeout: 60 * time.Minute, - Cluster: r.MakeClusterSpec(5, spec.CPU(4)), + Name: "lease-preferences/manual-violating-transfer", + Owner: registry.OwnerKV, + Timeout: 60 * time.Minute, + Cluster: r.MakeClusterSpec(5, spec.CPU(4)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLeasePreferences(ctx, t, c, leasePreferencesSpec{ preferences: `[+dc=1],[+dc=2]`, diff --git a/pkg/cmd/roachtest/tests/ledger.go b/pkg/cmd/roachtest/tests/ledger.go index fbef17403313..e0b66bf1a629 100644 --- a/pkg/cmd/roachtest/tests/ledger.go +++ b/pkg/cmd/roachtest/tests/ledger.go @@ -28,10 +28,12 @@ func registerLedger(r registry.Registry) { // https://github.com/cockroachdb/cockroach/issues/66184 const azs = "us-central1-f,us-central1-b,us-central1-c" r.Add(registry.TestSpec{ - Name: fmt.Sprintf("ledger/nodes=%d/multi-az", nodes), - Owner: registry.OwnerKV, - Benchmark: true, - Cluster: r.MakeClusterSpec(nodes+1, spec.CPU(16), spec.Geo(), spec.Zones(azs)), + Name: fmt.Sprintf("ledger/nodes=%d/multi-az", nodes), + Owner: registry.OwnerKV, + Benchmark: true, + Cluster: r.MakeClusterSpec(nodes+1, spec.CPU(16), spec.Geo(), spec.Zones(azs)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { roachNodes := c.Range(1, nodes) gatewayNodes := c.Range(1, nodes/3) diff --git a/pkg/cmd/roachtest/tests/libpq.go b/pkg/cmd/roachtest/tests/libpq.go index 12e27171bb08..548867045585 100644 --- a/pkg/cmd/roachtest/tests/libpq.go +++ b/pkg/cmd/roachtest/tests/libpq.go @@ -135,11 +135,13 @@ func registerLibPQ(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "lib/pq", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `driver`), - Run: runLibPQ, + Name: "lib/pq", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.Driver), + Tags: registry.Tags(`default`, `driver`), + Run: runLibPQ, }) } diff --git a/pkg/cmd/roachtest/tests/liquibase.go b/pkg/cmd/roachtest/tests/liquibase.go index 82fa7cb38efd..8c012de3f6a8 100644 --- a/pkg/cmd/roachtest/tests/liquibase.go +++ b/pkg/cmd/roachtest/tests/liquibase.go @@ -131,11 +131,13 @@ func registerLiquibase(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "liquibase", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `tool`), + Name: "liquibase", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.Tool), + Tags: registry.Tags(`default`, `tool`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLiquibase(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/loss_of_quorum_recovery.go b/pkg/cmd/roachtest/tests/loss_of_quorum_recovery.go index c0eb8a07cec2..83617c708aa8 100644 --- a/pkg/cmd/roachtest/tests/loss_of_quorum_recovery.go +++ b/pkg/cmd/roachtest/tests/loss_of_quorum_recovery.go @@ -72,7 +72,8 @@ func registerLOQRecovery(r registry.Registry) { Name: s.testName(""), Owner: registry.OwnerReplication, Benchmark: true, - Tags: registry.Tags(`default`), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Cluster: spec, Leases: registry.MetamorphicLeases, SkipPostValidations: registry.PostValidationInvalidDescriptors | registry.PostValidationNoDeadNodes, @@ -85,7 +86,8 @@ func registerLOQRecovery(r registry.Registry) { Name: s.testName("half-online"), Owner: registry.OwnerReplication, Benchmark: true, - Tags: registry.Tags(`default`), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Cluster: spec, Leases: registry.MetamorphicLeases, SkipPostValidations: registry.PostValidationInvalidDescriptors | registry.PostValidationNoDeadNodes, diff --git a/pkg/cmd/roachtest/tests/mixed_version_backup.go b/pkg/cmd/roachtest/tests/mixed_version_backup.go index 4713031af3c8..f7211c599a12 100644 --- a/pkg/cmd/roachtest/tests/mixed_version_backup.go +++ b/pkg/cmd/roachtest/tests/mixed_version_backup.go @@ -2333,6 +2333,8 @@ func registerBackupMixedVersion(r registry.Registry) { Cluster: r.MakeClusterSpec(5), EncryptionSupport: registry.EncryptionMetamorphic, RequiresLicense: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE && !c.IsLocal() { t.Skip("uses gs://cockroachdb-backup-testing-long-ttl; see https://github.com/cockroachdb/cockroach/issues/105968") diff --git a/pkg/cmd/roachtest/tests/mixed_version_cdc.go b/pkg/cmd/roachtest/tests/mixed_version_cdc.go index 35af915c7321..7f8c8eb1bc27 100644 --- a/pkg/cmd/roachtest/tests/mixed_version_cdc.go +++ b/pkg/cmd/roachtest/tests/mixed_version_cdc.go @@ -76,9 +76,11 @@ func registerCDCMixedVersions(r registry.Registry) { Name: "cdc/mixed-versions", Owner: registry.OwnerCDC, // N.B. ARM64 is not yet supported, see https://github.com/cockroachdb/cockroach/issues/103888. - Cluster: r.MakeClusterSpec(5, spec.Zones(zones), spec.Arch(vm.ArchAMD64)), - Timeout: 30 * time.Minute, - RequiresLicense: true, + Cluster: r.MakeClusterSpec(5, spec.Zones(zones), spec.Arch(vm.ArchAMD64)), + Timeout: 30 * time.Minute, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runCDCMixedVersions(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/mixed_version_change_replicas.go b/pkg/cmd/roachtest/tests/mixed_version_change_replicas.go index 7e12d15558a9..23006606f009 100644 --- a/pkg/cmd/roachtest/tests/mixed_version_change_replicas.go +++ b/pkg/cmd/roachtest/tests/mixed_version_change_replicas.go @@ -30,11 +30,13 @@ import ( func registerChangeReplicasMixedVersion(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "change-replicas/mixed-version", - Owner: registry.OwnerReplication, - Cluster: r.MakeClusterSpec(4), - Run: runChangeReplicasMixedVersion, - Timeout: 20 * time.Minute, + Name: "change-replicas/mixed-version", + Owner: registry.OwnerReplication, + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Run: runChangeReplicasMixedVersion, + Timeout: 20 * time.Minute, }) } diff --git a/pkg/cmd/roachtest/tests/mixed_version_decl_schemachange_compat.go b/pkg/cmd/roachtest/tests/mixed_version_decl_schemachange_compat.go index 4c0d189e3235..5f0c9b0e8ac8 100644 --- a/pkg/cmd/roachtest/tests/mixed_version_decl_schemachange_compat.go +++ b/pkg/cmd/roachtest/tests/mixed_version_decl_schemachange_compat.go @@ -28,9 +28,11 @@ import ( func registerDeclSchemaChangeCompatMixedVersions(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "schemachange/mixed-versions-compat", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), + Name: "schemachange/mixed-versions-compat", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE { t.Skip("uses gs://cockroach-corpus; see https://github.com/cockroachdb/cockroach/issues/105968") diff --git a/pkg/cmd/roachtest/tests/mixed_version_job_compatibility_in_declarative_schema_changer.go b/pkg/cmd/roachtest/tests/mixed_version_job_compatibility_in_declarative_schema_changer.go index 7ad03c454eb9..21ab130e4b3f 100644 --- a/pkg/cmd/roachtest/tests/mixed_version_job_compatibility_in_declarative_schema_changer.go +++ b/pkg/cmd/roachtest/tests/mixed_version_job_compatibility_in_declarative_schema_changer.go @@ -128,9 +128,11 @@ func registerDeclarativeSchemaChangerJobCompatibilityInMixedVersion(r registry.R // This test requires us to come back and change the to-be-tests stmts to be those // supported in the "previous" major release. r.Add(registry.TestSpec{ - Name: "declarative_schema_changer/job-compatibility-mixed-version-V222-V231", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(4), + Name: "declarative_schema_changer/job-compatibility-mixed-version-V222-V231", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { predV, err := release.LatestPredecessor(t.BuildVersion()) require.NoError(t, err) diff --git a/pkg/cmd/roachtest/tests/mixed_version_jobs.go b/pkg/cmd/roachtest/tests/mixed_version_jobs.go index 1443b5e6e573..4f440e66ae52 100644 --- a/pkg/cmd/roachtest/tests/mixed_version_jobs.go +++ b/pkg/cmd/roachtest/tests/mixed_version_jobs.go @@ -330,7 +330,9 @@ func registerJobsMixedVersions(r registry.Registry) { // state machine states `Status{Pause,Cancel}Requested`. This test purpose // is to to test the state transitions of jobs from paused to resumed and // vice versa in order to detect regressions in the work done for 20.1. - Cluster: r.MakeClusterSpec(4), + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { predV, err := release.LatestPredecessor(t.BuildVersion()) if err != nil { diff --git a/pkg/cmd/roachtest/tests/mixed_version_schemachange.go b/pkg/cmd/roachtest/tests/mixed_version_schemachange.go index 188a3fafd2ef..751420286362 100644 --- a/pkg/cmd/roachtest/tests/mixed_version_schemachange.go +++ b/pkg/cmd/roachtest/tests/mixed_version_schemachange.go @@ -29,8 +29,10 @@ func registerSchemaChangeMixedVersions(r registry.Registry) { // This tests the work done for 20.1 that made schema changes jobs and in // addition prevented making any new schema changes on a mixed cluster in // order to prevent bugs during upgrades. - Cluster: r.MakeClusterSpec(4), - NativeLibs: registry.LibGEOS, + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + NativeLibs: registry.LibGEOS, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { maxOps := 100 concurrency := 5 diff --git a/pkg/cmd/roachtest/tests/mixed_version_tenant_span_stats.go b/pkg/cmd/roachtest/tests/mixed_version_tenant_span_stats.go index e35a97967b2d..6377dd80453d 100644 --- a/pkg/cmd/roachtest/tests/mixed_version_tenant_span_stats.go +++ b/pkg/cmd/roachtest/tests/mixed_version_tenant_span_stats.go @@ -36,6 +36,8 @@ func registerTenantSpanStatsMixedVersion(r registry.Registry) { Name: "tenant-span-stats/mixed-version", Owner: registry.OwnerClusterObs, Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), EncryptionSupport: registry.EncryptionMetamorphic, Timeout: 30 * time.Minute, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { diff --git a/pkg/cmd/roachtest/tests/multitenant_distsql.go b/pkg/cmd/roachtest/tests/multitenant_distsql.go index 5767f91cf3a0..804c718ff07b 100644 --- a/pkg/cmd/roachtest/tests/multitenant_distsql.go +++ b/pkg/cmd/roachtest/tests/multitenant_distsql.go @@ -37,10 +37,12 @@ func registerMultiTenantDistSQL(r registry.Registry) { b := bundle to := timeout r.Add(registry.TestSpec{ - Name: fmt.Sprintf("multitenant/distsql/instances=%d/bundle=%s/timeout=%d", numInstances, b, to), - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(4), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("multitenant/distsql/instances=%d/bundle=%s/timeout=%d", numInstances, b, to), + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runMultiTenantDistSQL(ctx, t, c, numInstances, b == "on", to) }, diff --git a/pkg/cmd/roachtest/tests/multitenant_shared_process.go b/pkg/cmd/roachtest/tests/multitenant_shared_process.go index 9a1f33f7b3cb..ac4fb886f8bd 100644 --- a/pkg/cmd/roachtest/tests/multitenant_shared_process.go +++ b/pkg/cmd/roachtest/tests/multitenant_shared_process.go @@ -27,11 +27,13 @@ func registerMultiTenantSharedProcess(r registry.Registry) { crdbNodeCount := 4 r.Add(registry.TestSpec{ - Name: "multitenant/shared-process/basic", - Owner: registry.OwnerMultiTenant, - Cluster: r.MakeClusterSpec(crdbNodeCount + 1), - Leases: registry.MetamorphicLeases, - Timeout: 1 * time.Hour, + Name: "multitenant/shared-process/basic", + Owner: registry.OwnerMultiTenant, + Cluster: r.MakeClusterSpec(crdbNodeCount + 1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Timeout: 1 * time.Hour, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { var ( appTenantName = "app" diff --git a/pkg/cmd/roachtest/tests/multitenant_tpch.go b/pkg/cmd/roachtest/tests/multitenant_tpch.go index 9f3bd9dd4372..2bbe26c8a9b7 100644 --- a/pkg/cmd/roachtest/tests/multitenant_tpch.go +++ b/pkg/cmd/roachtest/tests/multitenant_tpch.go @@ -118,21 +118,25 @@ func runMultiTenantTPCH( func registerMultiTenantTPCH(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "multitenant/tpch", - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(1 /* nodeCount */), - Leases: registry.MetamorphicLeases, + Name: "multitenant/tpch", + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(1 /* nodeCount */), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runMultiTenantTPCH(ctx, t, c, false /* enableDirectScans */) }, }) r.Add(registry.TestSpec{ - Name: "multitenant/tpch_direct_scans", - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(1 /* nodeCount */), - Leases: registry.MetamorphicLeases, + Name: "multitenant/tpch_direct_scans", + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(1 /* nodeCount */), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runMultiTenantTPCH(ctx, t, c, true /* enableDirectScans */) }, diff --git a/pkg/cmd/roachtest/tests/multitenant_upgrade.go b/pkg/cmd/roachtest/tests/multitenant_upgrade.go index 38cc998ad9c6..d845352506fa 100644 --- a/pkg/cmd/roachtest/tests/multitenant_upgrade.go +++ b/pkg/cmd/roachtest/tests/multitenant_upgrade.go @@ -32,6 +32,8 @@ func registerMultiTenantUpgrade(r registry.Registry) { r.Add(registry.TestSpec{ Name: "multitenant-upgrade", Cluster: r.MakeClusterSpec(2), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Owner: registry.OwnerMultiTenant, NonReleaseBlocker: false, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { diff --git a/pkg/cmd/roachtest/tests/mvcc_gc.go b/pkg/cmd/roachtest/tests/mvcc_gc.go index 326c18dfb380..76c0f04d9eba 100644 --- a/pkg/cmd/roachtest/tests/mvcc_gc.go +++ b/pkg/cmd/roachtest/tests/mvcc_gc.go @@ -38,12 +38,14 @@ import ( func registerMVCCGC(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "mvcc_gc", - Owner: registry.OwnerKV, - Timeout: 30 * time.Minute, - Cluster: r.MakeClusterSpec(3), - Leases: registry.MetamorphicLeases, - Run: runMVCCGC, + Name: "mvcc_gc", + Owner: registry.OwnerKV, + Timeout: 30 * time.Minute, + Cluster: r.MakeClusterSpec(3), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Run: runMVCCGC, }) } diff --git a/pkg/cmd/roachtest/tests/network.go b/pkg/cmd/roachtest/tests/network.go index b5fa17f6fc94..da270a4331e7 100644 --- a/pkg/cmd/roachtest/tests/network.go +++ b/pkg/cmd/roachtest/tests/network.go @@ -298,10 +298,12 @@ sudo iptables-save func registerNetwork(r registry.Registry) { const numNodes = 4 r.Add(registry.TestSpec{ - Name: fmt.Sprintf("network/authentication/nodes=%d", numNodes), - Owner: registry.OwnerKV, // Should be moved to new security team once one exists. - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("network/authentication/nodes=%d", numNodes), + Owner: registry.OwnerKV, // Should be moved to new security team once one exists. + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runNetworkAuthentication(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/nodejs_postgres.go b/pkg/cmd/roachtest/tests/nodejs_postgres.go index bdc98f2cb3fd..ce3ccd325086 100644 --- a/pkg/cmd/roachtest/tests/nodejs_postgres.go +++ b/pkg/cmd/roachtest/tests/nodejs_postgres.go @@ -167,11 +167,13 @@ PGSSLCERT=$HOME/certs/client.%s.crt PGSSLKEY=$HOME/certs/client.%s.key PGSSLROOT } r.Add(registry.TestSpec{ - Name: "node-postgres", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `driver`), + Name: "node-postgres", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.Driver), + Tags: registry.Tags(`default`, `driver`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runNodeJSPostgres(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/npgsql.go b/pkg/cmd/roachtest/tests/npgsql.go index 56ce048222a0..bbe7e8730f8c 100644 --- a/pkg/cmd/roachtest/tests/npgsql.go +++ b/pkg/cmd/roachtest/tests/npgsql.go @@ -166,11 +166,13 @@ echo '%s' | git apply --ignore-whitespace -`, npgsqlPatch), } r.Add(registry.TestSpec{ - Name: "npgsql", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `driver`), + Name: "npgsql", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.Driver), + Tags: registry.Tags(`default`, `driver`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runNpgsql(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/pebble_write_throughput.go b/pkg/cmd/roachtest/tests/pebble_write_throughput.go index f9fc88128c1e..47fb061d81ab 100644 --- a/pkg/cmd/roachtest/tests/pebble_write_throughput.go +++ b/pkg/cmd/roachtest/tests/pebble_write_throughput.go @@ -32,13 +32,15 @@ func registerPebbleWriteThroughput(r registry.Registry) { // Register the Pebble write benchmark. We only run the 1024 variant for now. size := 1024 r.Add(registry.TestSpec{ - Name: fmt.Sprintf("pebble/write/size=%d", size), - Owner: registry.OwnerStorage, - Benchmark: true, - Timeout: 10 * time.Hour, - Cluster: r.MakeClusterSpec(5, spec.CPU(16), spec.SSD(16), spec.RAID0(true)), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags("pebble_nightly_write"), + Name: fmt.Sprintf("pebble/write/size=%d", size), + Owner: registry.OwnerStorage, + Benchmark: true, + Timeout: 10 * time.Hour, + Cluster: r.MakeClusterSpec(5, spec.CPU(16), spec.SSD(16), spec.RAID0(true)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.PebbleNightlyWrite), + Tags: registry.Tags("pebble_nightly_write"), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runPebbleWriteBenchmark(ctx, t, c, size, pebble) }, diff --git a/pkg/cmd/roachtest/tests/pebble_ycsb.go b/pkg/cmd/roachtest/tests/pebble_ycsb.go index a63707c9bdd7..9d53cf4b91be 100644 --- a/pkg/cmd/roachtest/tests/pebble_ycsb.go +++ b/pkg/cmd/roachtest/tests/pebble_ycsb.go @@ -39,6 +39,7 @@ func registerPebbleYCSB(r registry.Registry) { // relied-upon by the javascript on the Pebble Benchmarks webpage. name := fmt.Sprintf("pebble/ycsb/size=%d", size) tag := "pebble_nightly_ycsb" + suites := registry.Suites(registry.PebbleNightlyYCSB) // For the shorter benchmark runs, we append a suffix to the name to avoid // a name collision. This is safe to do as these tests are not executed as @@ -46,17 +47,20 @@ func registerPebbleYCSB(r registry.Registry) { // in build/teamcity-nightly-pebble.sh). if dur != 90 { tag = "pebble" + suites = registry.Suites(registry.Pebble) name += fmt.Sprintf("/duration=%d", dur) } d := dur r.Add(registry.TestSpec{ - Name: name, - Owner: registry.OwnerStorage, - Benchmark: true, - Timeout: 12 * time.Hour, - Cluster: r.MakeClusterSpec(5, spec.CPU(16)), - Tags: registry.Tags(tag), + Name: name, + Owner: registry.OwnerStorage, + Benchmark: true, + Timeout: 12 * time.Hour, + Cluster: r.MakeClusterSpec(5, spec.CPU(16)), + CompatibleClouds: registry.AllClouds, + Suites: suites, + Tags: registry.Tags(tag), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runPebbleYCSB(ctx, t, c, size, pebble, d, nil, true /* artifacts */) }, @@ -66,13 +70,15 @@ func registerPebbleYCSB(r registry.Registry) { // Add the race build. r.Add(registry.TestSpec{ - Name: "pebble/ycsb/A/race/duration=30", - Owner: registry.OwnerStorage, - Benchmark: true, - Timeout: 12 * time.Hour, - Cluster: r.MakeClusterSpec(5, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags("pebble_nightly_ycsb_race"), + Name: "pebble/ycsb/A/race/duration=30", + Owner: registry.OwnerStorage, + Benchmark: true, + Timeout: 12 * time.Hour, + Cluster: r.MakeClusterSpec(5, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.PebbleNightlyYCSBRace), + Tags: registry.Tags("pebble_nightly_ycsb_race"), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runPebbleYCSB(ctx, t, c, 64, pebble, 30, []string{"A"}, false /* artifacts */) }, diff --git a/pkg/cmd/roachtest/tests/pgjdbc.go b/pkg/cmd/roachtest/tests/pgjdbc.go index a278e4c8425a..6acb01feeead 100644 --- a/pkg/cmd/roachtest/tests/pgjdbc.go +++ b/pkg/cmd/roachtest/tests/pgjdbc.go @@ -210,11 +210,13 @@ func registerPgjdbc(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "pgjdbc", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `driver`), + Name: "pgjdbc", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.Driver), + Tags: registry.Tags(`default`, `driver`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runPgjdbc(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/pgx.go b/pkg/cmd/roachtest/tests/pgx.go index 34911fdcb25b..577e7154ab0f 100644 --- a/pkg/cmd/roachtest/tests/pgx.go +++ b/pkg/cmd/roachtest/tests/pgx.go @@ -131,11 +131,13 @@ func registerPgx(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "pgx", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `driver`), + Name: "pgx", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.Driver), + Tags: registry.Tags(`default`, `driver`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runPgx(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/pop.go b/pkg/cmd/roachtest/tests/pop.go index c12d98634f08..1a4de51cf375 100644 --- a/pkg/cmd/roachtest/tests/pop.go +++ b/pkg/cmd/roachtest/tests/pop.go @@ -99,11 +99,13 @@ func registerPop(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "pop", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `orm`), - Run: runPop, + Name: "pop", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), + Run: runPop, }) } diff --git a/pkg/cmd/roachtest/tests/process_lock.go b/pkg/cmd/roachtest/tests/process_lock.go index a23891785acc..e8ad886647b0 100644 --- a/pkg/cmd/roachtest/tests/process_lock.go +++ b/pkg/cmd/roachtest/tests/process_lock.go @@ -31,9 +31,11 @@ import ( func registerProcessLock(r registry.Registry) { const runDuration = 5 * time.Minute r.Add(registry.TestSpec{ - Name: "process-lock", - Owner: registry.OwnerStorage, - Cluster: r.MakeClusterSpec(4, spec.ReuseNone()), + Name: "process-lock", + Owner: registry.OwnerStorage, + Cluster: r.MakeClusterSpec(4, spec.ReuseNone()), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), // Encryption is implemented within the virtual filesystem layer, // just like disk-health monitoring. It's important to exercise // encryption-at-rest to ensure we don't corrupt the encryption-at-rest diff --git a/pkg/cmd/roachtest/tests/psycopg.go b/pkg/cmd/roachtest/tests/psycopg.go index 809553b3da6e..3696b08c01d8 100644 --- a/pkg/cmd/roachtest/tests/psycopg.go +++ b/pkg/cmd/roachtest/tests/psycopg.go @@ -140,11 +140,13 @@ func registerPsycopg(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "psycopg", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `driver`), + Name: "psycopg", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.Driver), + Tags: registry.Tags(`default`, `driver`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runPsycopg(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/queue.go b/pkg/cmd/roachtest/tests/queue.go index c4f3631e6caf..7521b9173d86 100644 --- a/pkg/cmd/roachtest/tests/queue.go +++ b/pkg/cmd/roachtest/tests/queue.go @@ -28,11 +28,13 @@ func registerQueue(r registry.Registry) { // One node runs the workload generator, all other nodes host CockroachDB. const numNodes = 2 r.Add(registry.TestSpec{ - Skip: "https://github.com/cockroachdb/cockroach/issues/17229", - Name: fmt.Sprintf("queue/nodes=%d", numNodes-1), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Skip: "https://github.com/cockroachdb/cockroach/issues/17229", + Name: fmt.Sprintf("queue/nodes=%d", numNodes-1), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runQueue(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/quit.go b/pkg/cmd/roachtest/tests/quit.go index 392cd7341ee2..80c411103dd6 100644 --- a/pkg/cmd/roachtest/tests/quit.go +++ b/pkg/cmd/roachtest/tests/quit.go @@ -360,10 +360,12 @@ func (q *quitTest) checkNoLeases(ctx context.Context, nodeID int) { func registerQuitTransfersLeases(r registry.Registry) { registerTest := func(name, minver string, method func(context.Context, test.Test, cluster.Cluster, int)) { r.Add(registry.TestSpec{ - Name: fmt.Sprintf("transfer-leases/%s", name), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(3), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("transfer-leases/%s", name), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(3), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runQuitTransfersLeases(ctx, t, c, name, method) }, diff --git a/pkg/cmd/roachtest/tests/rebalance_load.go b/pkg/cmd/roachtest/tests/rebalance_load.go index 61e9f5355a7f..591b610189f8 100644 --- a/pkg/cmd/roachtest/tests/rebalance_load.go +++ b/pkg/cmd/roachtest/tests/rebalance_load.go @@ -199,10 +199,12 @@ func registerRebalanceLoad(r registry.Registry) { r.Add( registry.TestSpec{ - Name: `rebalance/by-load/leases`, - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(4), // the last node is just used to generate load - Leases: registry.MetamorphicLeases, + Name: `rebalance/by-load/leases`, + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(4), // the last node is just used to generate load + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.IsLocal() { concurrency = 32 @@ -214,9 +216,11 @@ func registerRebalanceLoad(r registry.Registry) { ) r.Add( registry.TestSpec{ - Name: `rebalance/by-load/leases/mixed-version`, - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(4), // the last node is just used to generate load + Name: `rebalance/by-load/leases/mixed-version`, + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(4), // the last node is just used to generate load + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.IsLocal() { concurrency = 32 @@ -228,10 +232,12 @@ func registerRebalanceLoad(r registry.Registry) { ) r.Add( registry.TestSpec{ - Name: `rebalance/by-load/replicas`, - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(7), // the last node is just used to generate load - Leases: registry.MetamorphicLeases, + Name: `rebalance/by-load/replicas`, + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(7), // the last node is just used to generate load + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.IsLocal() { concurrency = 32 @@ -245,9 +251,11 @@ func registerRebalanceLoad(r registry.Registry) { ) r.Add( registry.TestSpec{ - Name: `rebalance/by-load/replicas/mixed-version`, - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(7), // the last node is just used to generate load + Name: `rebalance/by-load/replicas/mixed-version`, + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(7), // the last node is just used to generate load + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.IsLocal() { concurrency = 32 @@ -266,11 +274,13 @@ func registerRebalanceLoad(r registry.Registry) { } r.Add( registry.TestSpec{ - Skip: skip, - Name: `rebalance/by-load/replicas/ssds=2`, - Owner: registry.OwnerKV, - Cluster: cSpec, - Leases: registry.MetamorphicLeases, + Skip: skip, + Name: `rebalance/by-load/replicas/ssds=2`, + Owner: registry.OwnerKV, + Cluster: cSpec, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.IsLocal() { t.Fatal("cannot run multi-store in local mode") diff --git a/pkg/cmd/roachtest/tests/replicagc.go b/pkg/cmd/roachtest/tests/replicagc.go index dfd5c4807023..8487c90be9e3 100644 --- a/pkg/cmd/roachtest/tests/replicagc.go +++ b/pkg/cmd/roachtest/tests/replicagc.go @@ -30,10 +30,12 @@ import ( func registerReplicaGC(r registry.Registry) { for _, restart := range []bool{true, false} { r.Add(registry.TestSpec{ - Name: fmt.Sprintf("replicagc-changed-peers/restart=%t", restart), - Owner: registry.OwnerReplication, - Cluster: r.MakeClusterSpec(6), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("replicagc-changed-peers/restart=%t", restart), + Owner: registry.OwnerReplication, + Cluster: r.MakeClusterSpec(6), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runReplicaGCChangedPeers(ctx, t, c, restart) }, diff --git a/pkg/cmd/roachtest/tests/restart.go b/pkg/cmd/roachtest/tests/restart.go index 58428468c8a9..2975e8beece6 100644 --- a/pkg/cmd/roachtest/tests/restart.go +++ b/pkg/cmd/roachtest/tests/restart.go @@ -91,10 +91,12 @@ func runRestart(ctx context.Context, t test.Test, c cluster.Cluster, downDuratio func registerRestart(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "restart/down-for-2m", - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(3), - Leases: registry.MetamorphicLeases, + Name: "restart/down-for-2m", + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(3), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, // "cockroach workload is only in 19.1+" Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runRestart(ctx, t, c, 2*time.Minute) diff --git a/pkg/cmd/roachtest/tests/restore.go b/pkg/cmd/roachtest/tests/restore.go index 925f31534bab..dcbe304175c1 100644 --- a/pkg/cmd/roachtest/tests/restore.go +++ b/pkg/cmd/roachtest/tests/restore.go @@ -63,11 +63,13 @@ func registerRestoreNodeShutdown(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "restore/nodeShutdown/worker", - Owner: registry.OwnerDisasterRecovery, - Cluster: sp.hardware.makeClusterSpecs(r, sp.backup.cloud), - Leases: registry.MetamorphicLeases, - Timeout: sp.timeout, + Name: "restore/nodeShutdown/worker", + Owner: registry.OwnerDisasterRecovery, + Cluster: sp.hardware.makeClusterSpecs(r, sp.backup.cloud), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Timeout: sp.timeout, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { gatewayNode := 2 nodeToShutdown := 3 @@ -81,11 +83,13 @@ func registerRestoreNodeShutdown(r registry.Registry) { }) r.Add(registry.TestSpec{ - Name: "restore/nodeShutdown/coordinator", - Owner: registry.OwnerDisasterRecovery, - Cluster: sp.hardware.makeClusterSpecs(r, sp.backup.cloud), - Leases: registry.MetamorphicLeases, - Timeout: sp.timeout, + Name: "restore/nodeShutdown/coordinator", + Owner: registry.OwnerDisasterRecovery, + Cluster: sp.hardware.makeClusterSpecs(r, sp.backup.cloud), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Timeout: sp.timeout, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { gatewayNode := 2 @@ -118,12 +122,14 @@ func registerRestore(r registry.Registry) { withPauseSpecs.initTestName() r.Add(registry.TestSpec{ - Name: withPauseSpecs.testName, - Owner: registry.OwnerDisasterRecovery, - Benchmark: true, - Cluster: withPauseSpecs.hardware.makeClusterSpecs(r, withPauseSpecs.backup.cloud), - Timeout: withPauseSpecs.timeout, - Tags: registry.Tags("aws"), + Name: withPauseSpecs.testName, + Owner: registry.OwnerDisasterRecovery, + Benchmark: true, + Cluster: withPauseSpecs.hardware.makeClusterSpecs(r, withPauseSpecs.backup.cloud), + Timeout: withPauseSpecs.timeout, + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.Nightly), + Tags: registry.Tags("aws"), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -268,6 +274,8 @@ func registerRestore(r registry.Registry) { hardware: makeHardwareSpecs(hardwareSpecs{ebsThroughput: 250 /* MB/s */}), backup: makeBackupSpecs(backupSpecs{}), timeout: 1 * time.Hour, + clouds: registry.AllClouds, + suites: registry.Suites(registry.Nightly), tags: registry.Tags("aws"), }, { @@ -276,6 +284,8 @@ func registerRestore(r registry.Registry) { hardware: makeHardwareSpecs(hardwareSpecs{}), backup: makeBackupSpecs(backupSpecs{cloud: spec.GCE}), timeout: 1 * time.Hour, + clouds: registry.AllExceptAWS, + suites: registry.Suites(registry.Nightly), }, { // Benchmarks using a low memory per core ratio - we don't expect ideal @@ -283,6 +293,8 @@ func registerRestore(r registry.Registry) { hardware: makeHardwareSpecs(hardwareSpecs{mem: spec.Low}), backup: makeBackupSpecs(backupSpecs{cloud: spec.GCE}), timeout: 1 * time.Hour, + clouds: registry.AllExceptAWS, + suites: registry.Suites(registry.Nightly), }, { // Benchmarks if per node throughput remains constant if the number of @@ -290,6 +302,8 @@ func registerRestore(r registry.Registry) { hardware: makeHardwareSpecs(hardwareSpecs{nodes: 8, ebsThroughput: 250 /* MB/s */}), backup: makeBackupSpecs(backupSpecs{}), timeout: 1 * time.Hour, + clouds: registry.AllClouds, + suites: registry.Suites(registry.Nightly), tags: registry.Tags("aws"), }, { @@ -300,6 +314,9 @@ func registerRestore(r registry.Registry) { zones: []string{"us-east-2b", "us-west-2b", "eu-west-1b"}}), // These zones are AWS-specific. backup: makeBackupSpecs(backupSpecs{cloud: spec.AWS}), timeout: 90 * time.Minute, + clouds: registry.AllClouds, + suites: registry.Suites(registry.Nightly), + tags: registry.Tags("aws"), }, { // Benchmarks if per node throughput doubles if the vcpu count doubles @@ -307,6 +324,8 @@ func registerRestore(r registry.Registry) { hardware: makeHardwareSpecs(hardwareSpecs{cpus: 16, ebsThroughput: 250 /* MB/s */}), backup: makeBackupSpecs(backupSpecs{}), timeout: 1 * time.Hour, + clouds: registry.AllClouds, + suites: registry.Suites(registry.Nightly), tags: registry.Tags("aws"), }, { @@ -315,6 +334,8 @@ func registerRestore(r registry.Registry) { hardware: makeHardwareSpecs(hardwareSpecs{ebsThroughput: 250 /* MB/s */}), backup: makeBackupSpecs(backupSpecs{backupsIncluded: 48}), timeout: 1 * time.Hour, + clouds: registry.AllClouds, + suites: registry.Suites(registry.Nightly), tags: registry.Tags("aws"), }, { @@ -327,6 +348,8 @@ func registerRestore(r registry.Registry) { version: "v22.2.1", workload: tpceRestore{customers: 500000}}), timeout: 5 * time.Hour, + clouds: registry.AllClouds, + suites: registry.Suites(registry.Nightly), tags: registry.Tags("aws"), }, { @@ -337,6 +360,8 @@ func registerRestore(r registry.Registry) { version: "v22.2.1", workload: tpceRestore{customers: 2000000}}), timeout: 24 * time.Hour, + clouds: registry.AllClouds, + suites: registry.Suites(registry.Weekly), tags: registry.Tags("weekly", "aws-weekly"), }, { @@ -346,6 +371,8 @@ func registerRestore(r registry.Registry) { backupSpecs{workload: tpceRestore{customers: 1000}, version: "v22.2.1"}), timeout: 3 * time.Hour, + clouds: registry.AllExceptAWS, + suites: registry.Suites(registry.Nightly), fingerprint: 8445446819555404274, }, // TODO(msbutler): add the following tests once roachperf/grafana is hooked up and old tests are @@ -364,6 +391,8 @@ func registerRestore(r registry.Registry) { // These tests measure performance. To ensure consistent perf, // disable metamorphic encryption. EncryptionSupport: registry.EncryptionAlwaysDisabled, + CompatibleClouds: sp.clouds, + Suites: sp.suites, Tags: sp.tags, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -666,6 +695,8 @@ type restoreSpecs struct { hardware hardwareSpecs backup backupSpecs timeout time.Duration + clouds registry.CloudSet + suites registry.SuiteSet tags map[string]struct{} // namePrefix appears in the name of the roachtest, i.e. `restore/{prefix}/{config}`. diff --git a/pkg/cmd/roachtest/tests/roachmart.go b/pkg/cmd/roachtest/tests/roachmart.go index 1f1d5d872d04..c204ee5e4b05 100644 --- a/pkg/cmd/roachtest/tests/roachmart.go +++ b/pkg/cmd/roachtest/tests/roachmart.go @@ -72,10 +72,12 @@ func registerRoachmart(r registry.Registry) { for _, v := range []bool{true, false} { v := v r.Add(registry.TestSpec{ - Name: fmt.Sprintf("roachmart/partition=%v", v), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(9, spec.Geo(), spec.Zones("us-central1-b,us-west1-b,europe-west2-b")), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("roachmart/partition=%v", v), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(9, spec.Geo(), spec.Zones("us-central1-b,us-west1-b,europe-west2-b")), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runRoachmart(ctx, t, c, v) }, diff --git a/pkg/cmd/roachtest/tests/roachtest.go b/pkg/cmd/roachtest/tests/roachtest.go index 0f866694919a..9868ce0ec074 100644 --- a/pkg/cmd/roachtest/tests/roachtest.go +++ b/pkg/cmd/roachtest/tests/roachtest.go @@ -24,16 +24,20 @@ import ( func registerRoachtest(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "roachtest/noop", - Tags: registry.Tags("roachtest"), - Owner: registry.OwnerTestEng, - Run: func(_ context.Context, _ test.Test, _ cluster.Cluster) {}, - Cluster: r.MakeClusterSpec(0), + Name: "roachtest/noop", + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.Roachtest), + Tags: registry.Tags("roachtest"), + Owner: registry.OwnerTestEng, + Run: func(_ context.Context, _ test.Test, _ cluster.Cluster) {}, + Cluster: r.MakeClusterSpec(0), }) r.Add(registry.TestSpec{ - Name: "roachtest/noop-maybefail", - Tags: registry.Tags("roachtest"), - Owner: registry.OwnerTestEng, + Name: "roachtest/noop-maybefail", + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.Roachtest), + Tags: registry.Tags("roachtest"), + Owner: registry.OwnerTestEng, Run: func(_ context.Context, t test.Test, _ cluster.Cluster) { if rand.Float64() <= 0.2 { t.Fatal("randomly failing") @@ -44,9 +48,11 @@ func registerRoachtest(r registry.Registry) { // This test can be run manually to check what happens if a test times out. // In particular, can manually verify that suitable artifacts are created. r.Add(registry.TestSpec{ - Name: "roachtest/hang", - Tags: registry.Tags("roachtest"), - Owner: registry.OwnerTestEng, + Name: "roachtest/hang", + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.Roachtest), + Tags: registry.Tags("roachtest"), + Owner: registry.OwnerTestEng, Run: func(_ context.Context, t test.Test, c cluster.Cluster) { ctx := context.Background() // intentional c.Put(ctx, t.Cockroach(), "cockroach", c.All()) diff --git a/pkg/cmd/roachtest/tests/ruby_pg.go b/pkg/cmd/roachtest/tests/ruby_pg.go index 2dc385056885..f73024bd3d39 100644 --- a/pkg/cmd/roachtest/tests/ruby_pg.go +++ b/pkg/cmd/roachtest/tests/ruby_pg.go @@ -233,12 +233,14 @@ func registerRubyPG(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "ruby-pg", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1, spec.UbuntuVersion(vm.FocalFossa)), - Leases: registry.MetamorphicLeases, - NativeLibs: registry.LibGEOS, - Tags: registry.Tags(`default`, `orm`), + Name: "ruby-pg", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1, spec.UbuntuVersion(vm.FocalFossa)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Leases: registry.MetamorphicLeases, + NativeLibs: registry.LibGEOS, + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runRubyPGTest(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/rust_postgres.go b/pkg/cmd/roachtest/tests/rust_postgres.go index 5f761c410fc4..5b99e1e61087 100644 --- a/pkg/cmd/roachtest/tests/rust_postgres.go +++ b/pkg/cmd/roachtest/tests/rust_postgres.go @@ -170,11 +170,13 @@ func registerRustPostgres(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "rust-postgres", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1, spec.CPU(16)), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `orm`), + Name: "rust-postgres", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1, spec.CPU(16)), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runRustPostgres(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/schemachange.go b/pkg/cmd/roachtest/tests/schemachange.go index 6069c5cb223f..3bfb4fb35a8f 100644 --- a/pkg/cmd/roachtest/tests/schemachange.go +++ b/pkg/cmd/roachtest/tests/schemachange.go @@ -29,10 +29,12 @@ import ( func registerSchemaChangeDuringKV(r registry.Registry) { r.Add(registry.TestSpec{ - Name: `schemachange/during/kv`, - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(5), - Leases: registry.MetamorphicLeases, + Name: `schemachange/during/kv`, + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(5), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE { t.Skip("uses gs://cockroach-fixtures; see https://github.com/cockroachdb/cockroach/issues/105968") @@ -310,12 +312,14 @@ func makeIndexAddTpccTest( spec spec.ClusterSpec, warehouses int, length time.Duration, ) registry.TestSpec { return registry.TestSpec{ - Name: fmt.Sprintf("schemachange/index/tpcc/w=%d", warehouses), - Owner: registry.OwnerSQLFoundations, - Benchmark: true, - Cluster: spec, - Leases: registry.MetamorphicLeases, - Timeout: length * 3, + Name: fmt.Sprintf("schemachange/index/tpcc/w=%d", warehouses), + Owner: registry.OwnerSQLFoundations, + Benchmark: true, + Cluster: spec, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Timeout: length * 3, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCC(ctx, t, c, tpccOptions{ Warehouses: warehouses, @@ -344,11 +348,13 @@ func makeSchemaChangeBulkIngestTest( r registry.Registry, numNodes, numRows int, length time.Duration, ) registry.TestSpec { return registry.TestSpec{ - Name: "schemachange/bulkingest", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, - Timeout: length * 2, + Name: "schemachange/bulkingest", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Timeout: length * 2, // `fixtures import` (with the workload paths) is not supported in 2.1 Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { // Configure column a to have sequential ascending values, and columns b and c to be constant. @@ -431,12 +437,14 @@ func makeSchemaChangeDuringTPCC( spec spec.ClusterSpec, warehouses int, length time.Duration, ) registry.TestSpec { return registry.TestSpec{ - Name: "schemachange/during/tpcc", - Owner: registry.OwnerSQLFoundations, - Benchmark: true, - Cluster: spec, - Leases: registry.MetamorphicLeases, - Timeout: length * 3, + Name: "schemachange/during/tpcc", + Owner: registry.OwnerSQLFoundations, + Benchmark: true, + Cluster: spec, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Timeout: length * 3, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCC(ctx, t, c, tpccOptions{ Warehouses: warehouses, diff --git a/pkg/cmd/roachtest/tests/schemachange_random_load.go b/pkg/cmd/roachtest/tests/schemachange_random_load.go index 3e150490c6a7..36e43138037b 100644 --- a/pkg/cmd/roachtest/tests/schemachange_random_load.go +++ b/pkg/cmd/roachtest/tests/schemachange_random_load.go @@ -33,6 +33,8 @@ type randomLoadBenchSpec struct { Nodes int Ops int Concurrency int + Clouds registry.CloudSet + Suites registry.SuiteSet Tags map[string]struct{} } @@ -51,8 +53,10 @@ func registerSchemaChangeRandomLoad(r registry.Registry) { spec.Geo(), spec.Zones(geoZonesStr), ), - Leases: registry.MetamorphicLeases, - NativeLibs: registry.LibGEOS, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + NativeLibs: registry.LibGEOS, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { maxOps := 5000 concurrency := 20 @@ -69,6 +73,8 @@ func registerSchemaChangeRandomLoad(r registry.Registry) { Nodes: 3, Ops: 2000, Concurrency: 1, + Clouds: registry.AllClouds, + Suites: registry.Suites(registry.Nightly), Tags: registry.Tags("aws"), }) @@ -76,6 +82,8 @@ func registerSchemaChangeRandomLoad(r registry.Registry) { Nodes: 3, Ops: 10000, Concurrency: 20, + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) } @@ -102,7 +110,9 @@ func registerRandomLoadBenchSpec(r registry.Registry, b randomLoadBenchSpec) { Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runSchemaChangeRandomLoad(ctx, t, c, b.Ops, b.Concurrency) }, - Tags: b.Tags, + CompatibleClouds: b.Clouds, + Suites: b.Suites, + Tags: b.Tags, }) } diff --git a/pkg/cmd/roachtest/tests/scrub.go b/pkg/cmd/roachtest/tests/scrub.go index 404d154b1a83..432d4f6fb4a4 100644 --- a/pkg/cmd/roachtest/tests/scrub.go +++ b/pkg/cmd/roachtest/tests/scrub.go @@ -54,11 +54,13 @@ func makeScrubTPCCTest( } return registry.TestSpec{ - Name: fmt.Sprintf("scrub/%s/tpcc/w=%d", optionName, warehouses), - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("scrub/%s/tpcc/w=%d", optionName, warehouses), + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCC(ctx, t, c, tpccOptions{ Warehouses: warehouses, diff --git a/pkg/cmd/roachtest/tests/secondary_indexes.go b/pkg/cmd/roachtest/tests/secondary_indexes.go index 386f3a5860a0..b1f7e8391e23 100644 --- a/pkg/cmd/roachtest/tests/secondary_indexes.go +++ b/pkg/cmd/roachtest/tests/secondary_indexes.go @@ -135,9 +135,11 @@ func verifyTableData(node int, expected [][]int) versionStep { func registerSecondaryIndexesMultiVersionCluster(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "schemachange/secondary-index-multi-version", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(3), + Name: "schemachange/secondary-index-multi-version", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(3), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { predV, err := release.LatestPredecessor(t.BuildVersion()) if err != nil { diff --git a/pkg/cmd/roachtest/tests/sequelize.go b/pkg/cmd/roachtest/tests/sequelize.go index 79bd7314025b..f8a23ad487c2 100644 --- a/pkg/cmd/roachtest/tests/sequelize.go +++ b/pkg/cmd/roachtest/tests/sequelize.go @@ -154,12 +154,14 @@ func registerSequelize(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "sequelize", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - NativeLibs: registry.LibGEOS, - Tags: registry.Tags(`default`, `orm`), + Name: "sequelize", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + NativeLibs: registry.LibGEOS, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runSequelize(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/slow_drain.go b/pkg/cmd/roachtest/tests/slow_drain.go index a9a759d6000e..74659d778805 100644 --- a/pkg/cmd/roachtest/tests/slow_drain.go +++ b/pkg/cmd/roachtest/tests/slow_drain.go @@ -29,10 +29,12 @@ func registerSlowDrain(r registry.Registry) { duration := time.Minute r.Add(registry.TestSpec{ - Name: fmt.Sprintf("slow-drain/duration=%s", duration), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("slow-drain/duration=%s", duration), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runSlowDrain(ctx, t, c, duration) }, diff --git a/pkg/cmd/roachtest/tests/smoketest_secure.go b/pkg/cmd/roachtest/tests/smoketest_secure.go index c155112fc481..a4b5da81e8e3 100644 --- a/pkg/cmd/roachtest/tests/smoketest_secure.go +++ b/pkg/cmd/roachtest/tests/smoketest_secure.go @@ -27,11 +27,13 @@ import ( func registerSecure(r registry.Registry) { for _, numNodes := range []int{1, 3} { r.Add(registry.TestSpec{ - Name: fmt.Sprintf("smoketest/secure/nodes=%d", numNodes), - Tags: registry.Tags("smoketest", "weekly"), - Owner: registry.OwnerTestEng, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("smoketest/secure/nodes=%d", numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Smoketest, registry.Weekly), + Tags: registry.Tags("smoketest", "weekly"), + Owner: registry.OwnerTestEng, + Cluster: r.MakeClusterSpec(numNodes), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { c.Put(ctx, t.Cockroach(), "./cockroach") settings := install.MakeClusterSettings(install.SecureOption(true)) @@ -44,11 +46,13 @@ func registerSecure(r registry.Registry) { }) } r.Add(registry.TestSpec{ - Name: "smoketest/secure/multitenant", - Owner: registry.OwnerMultiTenant, - Cluster: r.MakeClusterSpec(2), - Leases: registry.MetamorphicLeases, - Run: multitenantSmokeTest, + Name: "smoketest/secure/multitenant", + Owner: registry.OwnerMultiTenant, + Cluster: r.MakeClusterSpec(2), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Run: multitenantSmokeTest, }) } diff --git a/pkg/cmd/roachtest/tests/split.go b/pkg/cmd/roachtest/tests/split.go index 3461757a3b43..1d33c6618e9b 100644 --- a/pkg/cmd/roachtest/tests/split.go +++ b/pkg/cmd/roachtest/tests/split.go @@ -148,10 +148,12 @@ func registerLoadSplits(r registry.Registry) { const numRoachNodes = 3 r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/uniform/nodes=%d", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/uniform/nodes=%d", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { // This number was determined experimentally. Often, but not always, // more splits will happen. @@ -194,10 +196,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/uniform/nodes=%d/obj=cpu", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/uniform/nodes=%d/obj=cpu", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -214,10 +218,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/sequential/nodes=%d", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/sequential/nodes=%d", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -236,10 +242,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/sequential/nodes=%d/obj=cpu", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/sequential/nodes=%d/obj=cpu", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -261,10 +269,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/spanning/nodes=%d", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/spanning/nodes=%d", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -280,10 +290,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/spanning/nodes=%d/obj=cpu", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/spanning/nodes=%d/obj=cpu", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -308,10 +320,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/ycsb/a/nodes=%d/obj=cpu", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/ycsb/a/nodes=%d/obj=cpu", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -331,10 +345,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/ycsb/b/nodes=%d/obj=cpu", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/ycsb/b/nodes=%d/obj=cpu", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -353,10 +369,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/ycsb/d/nodes=%d/obj=cpu", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/ycsb/d/nodes=%d/obj=cpu", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -376,10 +394,12 @@ func registerLoadSplits(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/load/ycsb/e/nodes=%d/obj=cpu", numRoachNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, + Name: fmt.Sprintf("splits/load/ycsb/e/nodes=%d/obj=cpu", numRoachNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLoadSplits(ctx, t, c, splitParams{ maxSize: 10 << 30, // 10 GB @@ -510,11 +530,13 @@ func registerLargeRange(r registry.Registry) { const size = 32 << 30 // 32 GB const numNodes = 6 r.Add(registry.TestSpec{ - Name: fmt.Sprintf("splits/largerange/size=%s,nodes=%d", bytesStr(size), numNodes), - Owner: registry.OwnerKV, - Cluster: r.MakeClusterSpec(numNodes), - Leases: registry.MetamorphicLeases, - Timeout: 5 * time.Hour, + Name: fmt.Sprintf("splits/largerange/size=%s,nodes=%d", bytesStr(size), numNodes), + Owner: registry.OwnerKV, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Timeout: 5 * time.Hour, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runLargeRangeSplits(ctx, t, c, size) }, diff --git a/pkg/cmd/roachtest/tests/sqlalchemy.go b/pkg/cmd/roachtest/tests/sqlalchemy.go index e8678d1f9d10..1029f1d6abf3 100644 --- a/pkg/cmd/roachtest/tests/sqlalchemy.go +++ b/pkg/cmd/roachtest/tests/sqlalchemy.go @@ -36,11 +36,13 @@ var supportedSQLAlchemyTag = "2.0.20" // node. func registerSQLAlchemy(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "sqlalchemy", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `orm`), + Name: "sqlalchemy", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runSQLAlchemy(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/sqlsmith.go b/pkg/cmd/roachtest/tests/sqlsmith.go index 996f82523c86..4dd67cc88466 100644 --- a/pkg/cmd/roachtest/tests/sqlsmith.go +++ b/pkg/cmd/roachtest/tests/sqlsmith.go @@ -283,13 +283,15 @@ WITH into_db = 'defaultdb', unsafe_restore_incompatible_version; clusterSpec = r.MakeClusterSpec(numNodes) } r.Add(registry.TestSpec{ - Name: fmt.Sprintf("sqlsmith/setup=%s/setting=%s", setup, setting), - Owner: registry.OwnerSQLQueries, - Cluster: clusterSpec, - Leases: registry.MetamorphicLeases, - NativeLibs: registry.LibGEOS, - Timeout: time.Minute * 20, - RequiresLicense: true, + Name: fmt.Sprintf("sqlsmith/setup=%s/setting=%s", setup, setting), + Owner: registry.OwnerSQLQueries, + Cluster: clusterSpec, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + NativeLibs: registry.LibGEOS, + Timeout: time.Minute * 20, + RequiresLicense: true, // NB: sqlsmith failures should never block a release. NonReleaseBlocker: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { diff --git a/pkg/cmd/roachtest/tests/sstable_corruption.go b/pkg/cmd/roachtest/tests/sstable_corruption.go index e502b7ca56a8..feb442036ed1 100644 --- a/pkg/cmd/roachtest/tests/sstable_corruption.go +++ b/pkg/cmd/roachtest/tests/sstable_corruption.go @@ -178,11 +178,13 @@ func runSSTableCorruption(ctx context.Context, t test.Test, c cluster.Cluster) { func registerSSTableCorruption(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "sstable-corruption/table", - Owner: registry.OwnerStorage, - Cluster: r.MakeClusterSpec(3), - Leases: registry.MetamorphicLeases, - Timeout: 2 * time.Hour, + Name: "sstable-corruption/table", + Owner: registry.OwnerStorage, + Cluster: r.MakeClusterSpec(3), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + Timeout: 2 * time.Hour, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runSSTableCorruption(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/synctest.go b/pkg/cmd/roachtest/tests/synctest.go index 8f79ef2f3275..365b0c17d023 100644 --- a/pkg/cmd/roachtest/tests/synctest.go +++ b/pkg/cmd/roachtest/tests/synctest.go @@ -36,8 +36,10 @@ fi Name: "synctest", Owner: registry.OwnerStorage, // This test sets up a custom file system; we don't want the cluster reused. - Cluster: r.MakeClusterSpec(1, spec.ReuseNone()), - Leases: registry.MetamorphicLeases, + Cluster: r.MakeClusterSpec(1, spec.ReuseNone()), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { n := c.Node(1) tmpDir, err := os.MkdirTemp("", "synctest") diff --git a/pkg/cmd/roachtest/tests/sysbench.go b/pkg/cmd/roachtest/tests/sysbench.go index a394ea326bbf..fceae814796b 100644 --- a/pkg/cmd/roachtest/tests/sysbench.go +++ b/pkg/cmd/roachtest/tests/sysbench.go @@ -154,9 +154,11 @@ func registerSysbench(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: fmt.Sprintf("sysbench/%s/nodes=%d/cpu=%d/conc=%d", w, n, cpus, conc), - Owner: registry.OwnerTestEng, - Cluster: r.MakeClusterSpec(n+1, spec.CPU(cpus)), + Name: fmt.Sprintf("sysbench/%s/nodes=%d/cpu=%d/conc=%d", w, n, cpus, conc), + Owner: registry.OwnerTestEng, + Cluster: r.MakeClusterSpec(n+1, spec.CPU(cpus)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runSysbench(ctx, t, c, opts) }, diff --git a/pkg/cmd/roachtest/tests/tlp.go b/pkg/cmd/roachtest/tests/tlp.go index 45ee0a81019c..667121794026 100644 --- a/pkg/cmd/roachtest/tests/tlp.go +++ b/pkg/cmd/roachtest/tests/tlp.go @@ -34,15 +34,17 @@ const statementTimeout = time.Minute func registerTLP(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "tlp", - Owner: registry.OwnerSQLQueries, - Timeout: time.Hour * 1, - RequiresLicense: true, - Tags: nil, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - NativeLibs: registry.LibGEOS, - Run: runTLP, + Name: "tlp", + Owner: registry.OwnerSQLQueries, + Timeout: time.Hour * 1, + RequiresLicense: true, + Tags: nil, + Cluster: r.MakeClusterSpec(1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Leases: registry.MetamorphicLeases, + NativeLibs: registry.LibGEOS, + Run: runTLP, }) } diff --git a/pkg/cmd/roachtest/tests/tpcc.go b/pkg/cmd/roachtest/tests/tpcc.go index d37663c001d1..f66e281855b5 100644 --- a/pkg/cmd/roachtest/tests/tpcc.go +++ b/pkg/cmd/roachtest/tests/tpcc.go @@ -492,6 +492,8 @@ func registerTPCC(r registry.Registry) { // running with the max supported warehouses. Name: "tpcc/headroom/" + headroomSpec.String(), Owner: registry.OwnerTestEng, + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.Nightly, registry.ReleaseQualification), Tags: registry.Tags(`default`, `release_qualification`, `aws`), Cluster: headroomSpec, EncryptionSupport: registry.EncryptionMetamorphic, @@ -518,6 +520,8 @@ func registerTPCC(r registry.Registry) { Owner: registry.OwnerTestEng, // TODO(tbg): add release_qualification tag once we know the test isn't // buggy. + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Tags: registry.Tags(`default`), Cluster: mixedHeadroomSpec, EncryptionSupport: registry.EncryptionMetamorphic, @@ -530,6 +534,8 @@ func registerTPCC(r registry.Registry) { // run the same mixed-headroom test, but going back two versions Name: "tpcc/mixed-headroom/multiple-upgrades/" + mixedHeadroomSpec.String(), Owner: registry.OwnerTestEng, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Tags: registry.Tags(`default`), Cluster: mixedHeadroomSpec, EncryptionSupport: registry.EncryptionMetamorphic, @@ -541,6 +547,8 @@ func registerTPCC(r registry.Registry) { Name: "tpcc-nowait/nodes=3/w=1", Owner: registry.OwnerTestEng, Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -553,10 +561,12 @@ func registerTPCC(r registry.Registry) { }, }) r.Add(registry.TestSpec{ - Name: "weekly/tpcc/headroom", - Owner: registry.OwnerTestEng, - Tags: registry.Tags(`weekly`), - Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + Name: "weekly/tpcc/headroom", + Owner: registry.OwnerTestEng, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), + Cluster: r.MakeClusterSpec(4, spec.CPU(16)), // Give the test a generous extra 10 hours to load the dataset and // slowly ramp up the load. Timeout: 4*24*time.Hour + 10*time.Hour, @@ -679,6 +689,8 @@ func registerTPCC(r registry.Registry) { Owner: registry.OwnerSQLFoundations, // Add an extra node which serves as the workload nodes. Cluster: r.MakeClusterSpec(len(regions)*nodesPerRegion+1, spec.Geo(), spec.Zones(strings.Join(zs, ","))), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -771,6 +783,8 @@ func registerTPCC(r registry.Registry) { Name: "tpcc/w=100/nodes=3/chaos=true", Owner: registry.OwnerTestEng, Cluster: r.MakeClusterSpec(4), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { @@ -800,6 +814,8 @@ func registerTPCC(r registry.Registry) { Name: "tpcc/interleaved/nodes=3/cpu=16/w=500", Owner: registry.OwnerSQLQueries, Cluster: r.MakeClusterSpec(4, spec.CPU(16)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Timeout: 6 * time.Hour, EncryptionSupport: registry.EncryptionMetamorphic, Leases: registry.MetamorphicLeases, @@ -825,6 +841,9 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: 1000, EstimatedMax: gceOrAws(cloud, 750, 900), + + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) registerTPCCBenchSpec(r, tpccBenchSpec{ Nodes: 3, @@ -832,6 +851,8 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: gceOrAws(cloud, 3500, 3900), EstimatedMax: gceOrAws(cloud, 2900, 3500), + Clouds: registry.AllClouds, + Suites: registry.Suites(registry.Nightly), Tags: registry.Tags(`aws`), }) registerTPCCBenchSpec(r, tpccBenchSpec{ @@ -841,7 +862,9 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: gceOrAws(cloud, 11500, 11500), EstimatedMax: gceOrAws(cloud, 10000, 10000), - Tags: registry.Tags(`weekly`), + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), }) registerTPCCBenchSpec(r, tpccBenchSpec{ Nodes: 6, @@ -850,6 +873,9 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: 6500, EstimatedMax: 5000, + + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) registerTPCCBenchSpec(r, tpccBenchSpec{ Nodes: 9, @@ -860,6 +886,9 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: 3000, EstimatedMax: 2000, + + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) registerTPCCBenchSpec(r, tpccBenchSpec{ Nodes: 9, @@ -869,6 +898,9 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: 2000, EstimatedMax: 900, + + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) // Encryption-At-Rest benchmarks. These are duplicates of variants above, @@ -880,6 +912,9 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: 1000, EstimatedMax: gceOrAws(cloud, 750, 900), EncryptionEnabled: true, + + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) registerTPCCBenchSpec(r, tpccBenchSpec{ Nodes: 3, @@ -888,6 +923,8 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: gceOrAws(cloud, 3500, 3900), EstimatedMax: gceOrAws(cloud, 2900, 3500), EncryptionEnabled: true, + Clouds: registry.AllClouds, + Suites: registry.Suites(registry.Nightly), Tags: registry.Tags(`aws`), }) registerTPCCBenchSpec(r, tpccBenchSpec{ @@ -898,7 +935,9 @@ func registerTPCC(r registry.Registry) { EstimatedMax: gceOrAws(cloud, 10000, 10000), EncryptionEnabled: true, - Tags: registry.Tags(`weekly`), + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), }) // Expiration lease benchmarks. These are duplicates of variants above. @@ -909,6 +948,9 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: 1000, EstimatedMax: gceOrAws(cloud, 750, 900), ExpirationLeases: true, + + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) registerTPCCBenchSpec(r, tpccBenchSpec{ Nodes: 3, @@ -917,6 +959,8 @@ func registerTPCC(r registry.Registry) { LoadWarehouses: gceOrAws(cloud, 3500, 3900), EstimatedMax: gceOrAws(cloud, 2900, 3500), ExpirationLeases: true, + Clouds: registry.AllClouds, + Suites: registry.Suites(registry.Nightly), Tags: registry.Tags(`aws`), }) registerTPCCBenchSpec(r, tpccBenchSpec{ @@ -927,7 +971,9 @@ func registerTPCC(r registry.Registry) { EstimatedMax: gceOrAws(cloud, 10000, 10000), ExpirationLeases: true, - Tags: registry.Tags(`weekly`), + Clouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags(`weekly`), }) } @@ -1016,6 +1062,9 @@ type tpccBenchSpec struct { // MinVersion to pass to testRegistryImpl.Add. MinVersion string + + Clouds registry.CloudSet + Suites registry.SuiteSet // Tags to pass to testRegistryImpl.Add. Tags map[string]struct{} // EncryptionEnabled determines if the benchmark uses encrypted stores (i.e. @@ -1121,6 +1170,8 @@ func registerTPCCBenchSpec(r registry.Registry, b tpccBenchSpec) { Owner: owner, Benchmark: true, Cluster: nodes, + CompatibleClouds: b.Clouds, + Suites: b.Suites, Tags: b.Tags, EncryptionSupport: encryptionSupport, Leases: leases, diff --git a/pkg/cmd/roachtest/tests/tpcdsvec.go b/pkg/cmd/roachtest/tests/tpcdsvec.go index 8043f0682c2a..209bbd507fcc 100644 --- a/pkg/cmd/roachtest/tests/tpcdsvec.go +++ b/pkg/cmd/roachtest/tests/tpcdsvec.go @@ -186,10 +186,12 @@ WITH unsafe_restore_incompatible_version; } r.Add(registry.TestSpec{ - Name: "tpcdsvec", - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(3), + Name: "tpcdsvec", + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(3), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { if c.Spec().Cloud != spec.GCE { t.Skip("uses gs://cockroach-fixtures; see https://github.com/cockroachdb/cockroach/issues/105968") diff --git a/pkg/cmd/roachtest/tests/tpce.go b/pkg/cmd/roachtest/tests/tpce.go index f50f93bb33ce..09cfdb75f879 100644 --- a/pkg/cmd/roachtest/tests/tpce.go +++ b/pkg/cmd/roachtest/tests/tpce.go @@ -27,14 +27,10 @@ import ( func registerTPCE(r registry.Registry) { type tpceOptions struct { - owner registry.Owner // defaults to test-eng customers int nodes int cpus int ssds int - - tags map[string]struct{} - timeout time.Duration } runTPCE := func(ctx context.Context, t test.Test, c cluster.Cluster, opts tpceOptions) { @@ -106,26 +102,42 @@ func registerTPCE(r registry.Registry) { m.Wait() } - for _, opts := range []tpceOptions{ - // Nightly, small scale configurations. - {customers: 5_000, nodes: 3, cpus: 4, ssds: 1}, - // Weekly, large scale configurations. - {customers: 100_000, nodes: 5, cpus: 32, ssds: 2, tags: registry.Tags("weekly"), timeout: 36 * time.Hour}, - } { - opts := opts - owner := registry.OwnerTestEng - if opts.owner != "" { - owner = opts.owner - } - r.Add(registry.TestSpec{ - Name: fmt.Sprintf("tpce/c=%d/nodes=%d", opts.customers, opts.nodes), - Owner: owner, - Tags: opts.tags, - Timeout: opts.timeout, - Cluster: r.MakeClusterSpec(opts.nodes+1, spec.CPU(opts.cpus), spec.SSD(opts.ssds)), - Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { - runTPCE(ctx, t, c, opts) - }, - }) + // Nightly, small scale configuration. + smallNightly := tpceOptions{ + customers: 5_000, + nodes: 3, + cpus: 4, + ssds: 1, + } + r.Add(registry.TestSpec{ + Name: fmt.Sprintf("tpce/c=%d/nodes=%d", smallNightly.customers, smallNightly.nodes), + Owner: registry.OwnerTestEng, + Timeout: 4 * time.Hour, + Cluster: r.MakeClusterSpec(smallNightly.nodes+1, spec.CPU(smallNightly.cpus), spec.SSD(smallNightly.ssds)), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { + runTPCE(ctx, t, c, smallNightly) + }, + }) + + // Weekly, large scale configuration. + largeWeekly := tpceOptions{ + customers: 100_000, + nodes: 5, + cpus: 32, + ssds: 2, } + r.Add(registry.TestSpec{ + Name: fmt.Sprintf("tpce/c=%d/nodes=%d", largeWeekly.customers, largeWeekly.nodes), + Owner: registry.OwnerTestEng, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Weekly), + Tags: registry.Tags("weekly"), + Timeout: 36 * time.Hour, + Cluster: r.MakeClusterSpec(largeWeekly.nodes+1, spec.CPU(largeWeekly.cpus), spec.SSD(largeWeekly.ssds)), + Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { + runTPCE(ctx, t, c, largeWeekly) + }, + }) } diff --git a/pkg/cmd/roachtest/tests/tpch_concurrency.go b/pkg/cmd/roachtest/tests/tpch_concurrency.go index 81a8d861740c..be127abb9752 100644 --- a/pkg/cmd/roachtest/tests/tpch_concurrency.go +++ b/pkg/cmd/roachtest/tests/tpch_concurrency.go @@ -201,22 +201,26 @@ func registerTPCHConcurrency(r registry.Registry) { const timeout = 18 * time.Hour r.Add(registry.TestSpec{ - Name: "tpch_concurrency", - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Timeout: timeout, - Cluster: r.MakeClusterSpec(numNodes), + Name: "tpch_concurrency", + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Timeout: timeout, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCHConcurrency(ctx, t, c, false /* disableStreamer */) }, }) r.Add(registry.TestSpec{ - Name: "tpch_concurrency/no_streamer", - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Timeout: timeout, - Cluster: r.MakeClusterSpec(numNodes), + Name: "tpch_concurrency/no_streamer", + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Timeout: timeout, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCHConcurrency(ctx, t, c, true /* disableStreamer */) }, diff --git a/pkg/cmd/roachtest/tests/tpchbench.go b/pkg/cmd/roachtest/tests/tpchbench.go index 3aa99825cafc..c630e6ee4181 100644 --- a/pkg/cmd/roachtest/tests/tpchbench.go +++ b/pkg/cmd/roachtest/tests/tpchbench.go @@ -172,10 +172,12 @@ func registerTPCHBenchSpec(r registry.Registry, b tpchBenchSpec) { } r.Add(registry.TestSpec{ - Name: strings.Join(nameParts, "/"), - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(numNodes), + Name: strings.Join(nameParts, "/"), + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(numNodes), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCHBench(ctx, t, c, b) }, diff --git a/pkg/cmd/roachtest/tests/tpchvec.go b/pkg/cmd/roachtest/tests/tpchvec.go index cefcae8be936..81661c0b1796 100644 --- a/pkg/cmd/roachtest/tests/tpchvec.go +++ b/pkg/cmd/roachtest/tests/tpchvec.go @@ -598,10 +598,12 @@ const tpchVecNodeCount = 3 func registerTPCHVec(r registry.Registry) { r.Add(registry.TestSpec{ - Name: "tpchvec/perf", - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(tpchVecNodeCount), + Name: "tpchvec/perf", + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(tpchVecNodeCount), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCHVec(ctx, t, c, newTpchVecPerfTest( "sql.defaults.vectorize", /* settingName */ @@ -611,29 +613,35 @@ func registerTPCHVec(r registry.Registry) { }) r.Add(registry.TestSpec{ - Name: "tpchvec/disk", - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(tpchVecNodeCount), + Name: "tpchvec/disk", + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(tpchVecNodeCount), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCHVec(ctx, t, c, tpchVecDiskTest{}, baseTestRun) }, }) r.Add(registry.TestSpec{ - Name: "tpchvec/smithcmp", - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(tpchVecNodeCount), - RequiresLicense: true, + Name: "tpchvec/smithcmp", + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(tpchVecNodeCount), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + RequiresLicense: true, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCHVec(ctx, t, c, tpchVecSmithcmpTest{}, smithcmpTestRun) }, }) r.Add(registry.TestSpec{ - Name: "tpchvec/streamer", - Owner: registry.OwnerSQLQueries, - Benchmark: true, - Cluster: r.MakeClusterSpec(tpchVecNodeCount), + Name: "tpchvec/streamer", + Owner: registry.OwnerSQLQueries, + Benchmark: true, + Cluster: r.MakeClusterSpec(tpchVecNodeCount), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTPCHVec(ctx, t, c, newTpchVecPerfTest( "sql.distsql.use_streamer.enabled", /* settingName */ @@ -643,9 +651,11 @@ func registerTPCHVec(r registry.Registry) { }) r.Add(registry.TestSpec{ - Name: "tpchvec/bench", - Owner: registry.OwnerSQLQueries, - Cluster: r.MakeClusterSpec(tpchVecNodeCount), + Name: "tpchvec/bench", + Owner: registry.OwnerSQLQueries, + Cluster: r.MakeClusterSpec(tpchVecNodeCount), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Skip: "This config can be used to perform some benchmarking and is not " + "meant to be run on a nightly basis", Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { diff --git a/pkg/cmd/roachtest/tests/typeorm.go b/pkg/cmd/roachtest/tests/typeorm.go index 55742c1abf2a..9827c1cdff55 100644 --- a/pkg/cmd/roachtest/tests/typeorm.go +++ b/pkg/cmd/roachtest/tests/typeorm.go @@ -201,11 +201,13 @@ func registerTypeORM(r registry.Registry) { } r.Add(registry.TestSpec{ - Name: "typeorm", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), - Leases: registry.MetamorphicLeases, - Tags: registry.Tags(`default`, `orm`), + Name: "typeorm", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + Leases: registry.MetamorphicLeases, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly, registry.ORM), + Tags: registry.Tags(`default`, `orm`), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runTypeORM(ctx, t, c) }, diff --git a/pkg/cmd/roachtest/tests/unoptimized_query_oracle.go b/pkg/cmd/roachtest/tests/unoptimized_query_oracle.go index b64f112c3476..5c974c6c2019 100644 --- a/pkg/cmd/roachtest/tests/unoptimized_query_oracle.go +++ b/pkg/cmd/roachtest/tests/unoptimized_query_oracle.go @@ -54,11 +54,13 @@ func registerUnoptimizedQueryOracle(r registry.Registry) { Name: fmt.Sprintf( "unoptimized-query-oracle/disable-rules=%s/%s", disableRuleSpec.disableRules, setupName, ), - Owner: registry.OwnerSQLQueries, - Timeout: time.Hour * 1, - RequiresLicense: true, - Tags: nil, - Cluster: clusterSpec, + Owner: registry.OwnerSQLQueries, + Timeout: time.Hour * 1, + RequiresLicense: true, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), + Tags: nil, + Cluster: clusterSpec, Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runQueryComparison(ctx, t, c, &queryComparisonTest{ name: "unoptimized-query-oracle", diff --git a/pkg/cmd/roachtest/tests/validate_system_schema_after_version_upgrade.go b/pkg/cmd/roachtest/tests/validate_system_schema_after_version_upgrade.go index b0a5bff045bf..a4f617da4474 100644 --- a/pkg/cmd/roachtest/tests/validate_system_schema_after_version_upgrade.go +++ b/pkg/cmd/roachtest/tests/validate_system_schema_after_version_upgrade.go @@ -31,9 +31,11 @@ func registerValidateSystemSchemaAfterVersionUpgrade(r registry.Registry) { // Specifically, we do the check with `USE system; SHOW CREATE ALL TABLES;` // and assert that the output matches the expected output content. r.Add(registry.TestSpec{ - Name: "systemschema/validate-after-version-upgrade", - Owner: registry.OwnerSQLFoundations, - Cluster: r.MakeClusterSpec(1), + Name: "systemschema/validate-after-version-upgrade", + Owner: registry.OwnerSQLFoundations, + Cluster: r.MakeClusterSpec(1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { predecessorVersion, err := release.LatestPredecessor(t.BuildVersion()) if err != nil { diff --git a/pkg/cmd/roachtest/tests/version.go b/pkg/cmd/roachtest/tests/version.go index 590e7bb13311..237733601c28 100644 --- a/pkg/cmd/roachtest/tests/version.go +++ b/pkg/cmd/roachtest/tests/version.go @@ -218,9 +218,11 @@ func registerVersion(r registry.Registry) { for _, n := range []int{3, 5} { r.Add(registry.TestSpec{ - Name: fmt.Sprintf("version/mixed/nodes=%d", n), - Owner: registry.OwnerTestEng, - Cluster: r.MakeClusterSpec(n + 1), + Name: fmt.Sprintf("version/mixed/nodes=%d", n), + Owner: registry.OwnerTestEng, + Cluster: r.MakeClusterSpec(n + 1), + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { pred, err := release.LatestPredecessor(t.BuildVersion()) if err != nil { diff --git a/pkg/cmd/roachtest/tests/ycsb.go b/pkg/cmd/roachtest/tests/ycsb.go index 3145b33a08e2..fa935bfbf1e3 100644 --- a/pkg/cmd/roachtest/tests/ycsb.go +++ b/pkg/cmd/roachtest/tests/ycsb.go @@ -109,7 +109,9 @@ func registerYCSB(r registry.Registry) { Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runYCSB(ctx, t, c, wl, cpus, false /* rangeTombstone */) }, - Tags: registry.Tags(`aws`), + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.Nightly), + Tags: registry.Tags(`aws`), }) if wl == "A" { @@ -121,6 +123,8 @@ func registerYCSB(r registry.Registry) { Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runYCSB(ctx, t, c, wl, cpus, false /* rangeTombstone */) }, + CompatibleClouds: registry.AllExceptAWS, + Suites: registry.Suites(registry.Nightly), }) } @@ -133,7 +137,9 @@ func registerYCSB(r registry.Registry) { Run: func(ctx context.Context, t test.Test, c cluster.Cluster) { runYCSB(ctx, t, c, wl, cpus, true /* rangeTombstone */) }, - Tags: registry.Tags(`aws`), + CompatibleClouds: registry.AllClouds, + Suites: registry.Suites(registry.Nightly), + Tags: registry.Tags(`aws`), }) } }