From 9bec6624930ebf33e0283ecd64681fb9ce87e082 Mon Sep 17 00:00:00 2001 From: Radu Berinde Date: Fri, 22 Sep 2023 13:49:34 -0700 Subject: [PATCH] roachtest: add CompatibleClouds and Suites to TestSpec The roachtest tags have gotten very messy, with no better example than that we run the nightly GCE suite using `tag:aws tag:default`. This change is the first step to replacing the tags with more structured information. We add two new fields to `TestSpec`: - `CompatibleClouds` is the set of clouds that the test can run on. - `Suites` is a set of test suites. The fields are strongly typed and only allow specific values. The intention is that we will (for example) run the nightly tests using `roachtest run --cloud=XX --suite nightly` In this change we mechanically assign the maximum set of compatible clouds so that the nightly suites on GCE and AWS remain unchanged. We assert that all tests have the two new fields *explicitly* set and that the test suites match those selected by tags. In follow-up changes we will add selection flags like `--suite`, replace uses of tags in scripts, and remove the tags altogether. Informs: #100605 Release note: None --- pkg/BUILD.bazel | 2 + pkg/cmd/roachtest/main_test.go | 10 +- pkg/cmd/roachtest/registry/BUILD.bazel | 13 +- pkg/cmd/roachtest/registry/test_spec.go | 224 ++++++++++++++++++ pkg/cmd/roachtest/registry/test_spec_test.go | 45 ++++ pkg/cmd/roachtest/test_registry.go | 4 + pkg/cmd/roachtest/test_test.go | 64 +++-- pkg/cmd/roachtest/tests/acceptance.go | 2 + pkg/cmd/roachtest/tests/activerecord.go | 16 +- .../tests/admission_control_elastic_backup.go | 14 +- .../tests/admission_control_elastic_cdc.go | 16 +- .../tests/admission_control_index_overload.go | 14 +- .../admission_control_multi_store_overload.go | 14 +- .../admission_control_multitenant_fairness.go | 2 + .../admission_control_snapshot_overload.go | 14 +- .../tests/admission_control_tpcc_overload.go | 8 +- pkg/cmd/roachtest/tests/allocation_bench.go | 2 + pkg/cmd/roachtest/tests/allocator.go | 40 ++-- pkg/cmd/roachtest/tests/alterpk.go | 20 +- pkg/cmd/roachtest/tests/asyncpg.go | 12 +- pkg/cmd/roachtest/tests/autoupgrade.go | 8 +- pkg/cmd/roachtest/tests/awsdms.go | 14 +- pkg/cmd/roachtest/tests/backup.go | 19 +- .../tests/backup_restore_roundtrip.go | 2 + pkg/cmd/roachtest/tests/cancel.go | 20 +- pkg/cmd/roachtest/tests/cdc.go | 213 ++++++++++------- pkg/cmd/roachtest/tests/clearrange.go | 11 +- pkg/cmd/roachtest/tests/clock_jump_crash.go | 6 +- pkg/cmd/roachtest/tests/clock_monotonic.go | 6 +- pkg/cmd/roachtest/tests/cluster_to_cluster.go | 41 +++- pkg/cmd/roachtest/tests/connection_latency.go | 24 +- pkg/cmd/roachtest/tests/copy.go | 10 +- pkg/cmd/roachtest/tests/copyfrom.go | 36 +-- pkg/cmd/roachtest/tests/costfuzz.go | 18 +- pkg/cmd/roachtest/tests/decommission.go | 60 +++-- pkg/cmd/roachtest/tests/decommissionbench.go | 2 + pkg/cmd/roachtest/tests/disk_full.go | 10 +- pkg/cmd/roachtest/tests/disk_stall.go | 2 + pkg/cmd/roachtest/tests/django.go | 12 +- pkg/cmd/roachtest/tests/drain.go | 22 +- pkg/cmd/roachtest/tests/drop.go | 10 +- pkg/cmd/roachtest/tests/encryption.go | 2 + pkg/cmd/roachtest/tests/failover.go | 56 +++-- pkg/cmd/roachtest/tests/fixtures.go | 14 +- pkg/cmd/roachtest/tests/flowable.go | 10 +- pkg/cmd/roachtest/tests/follower_reads.go | 6 +- pkg/cmd/roachtest/tests/gopg.go | 12 +- pkg/cmd/roachtest/tests/gorm.go | 14 +- pkg/cmd/roachtest/tests/gossip.go | 10 +- pkg/cmd/roachtest/tests/hibernate.go | 14 +- pkg/cmd/roachtest/tests/hotspotsplits.go | 6 +- pkg/cmd/roachtest/tests/import.go | 42 ++-- .../roachtest/tests/import_cancellation.go | 15 +- pkg/cmd/roachtest/tests/inconsistency.go | 12 +- pkg/cmd/roachtest/tests/indexes.go | 10 +- pkg/cmd/roachtest/tests/inverted_index.go | 10 +- pkg/cmd/roachtest/tests/jasyncsql.go | 12 +- pkg/cmd/roachtest/tests/jepsen.go | 6 +- pkg/cmd/roachtest/tests/knex.go | 14 +- pkg/cmd/roachtest/tests/kv.go | 98 +++++--- pkg/cmd/roachtest/tests/kvbench.go | 8 +- pkg/cmd/roachtest/tests/lease_preferences.go | 14 +- pkg/cmd/roachtest/tests/ledger.go | 10 +- pkg/cmd/roachtest/tests/libpq.go | 14 +- pkg/cmd/roachtest/tests/liquibase.go | 12 +- .../tests/loss_of_quorum_recovery.go | 6 +- .../roachtest/tests/mixed_version_backup.go | 2 + pkg/cmd/roachtest/tests/mixed_version_cdc.go | 8 +- .../tests/mixed_version_change_replicas.go | 12 +- .../mixed_version_decl_schemachange_compat.go | 8 +- ...atibility_in_declarative_schema_changer.go | 8 +- pkg/cmd/roachtest/tests/mixed_version_jobs.go | 4 +- .../tests/mixed_version_schemachange.go | 6 +- .../tests/mixed_version_tenant_span_stats.go | 2 + .../roachtest/tests/multitenant_distsql.go | 10 +- .../tests/multitenant_shared_process.go | 12 +- pkg/cmd/roachtest/tests/multitenant_tpch.go | 24 +- .../roachtest/tests/multitenant_upgrade.go | 2 + pkg/cmd/roachtest/tests/mvcc_gc.go | 14 +- pkg/cmd/roachtest/tests/network.go | 10 +- pkg/cmd/roachtest/tests/nodejs_postgres.go | 12 +- pkg/cmd/roachtest/tests/npgsql.go | 12 +- .../tests/pebble_write_throughput.go | 16 +- pkg/cmd/roachtest/tests/pebble_ycsb.go | 32 ++- pkg/cmd/roachtest/tests/pgjdbc.go | 12 +- pkg/cmd/roachtest/tests/pgx.go | 12 +- pkg/cmd/roachtest/tests/pop.go | 14 +- pkg/cmd/roachtest/tests/process_lock.go | 8 +- pkg/cmd/roachtest/tests/psycopg.go | 12 +- pkg/cmd/roachtest/tests/queue.go | 12 +- pkg/cmd/roachtest/tests/quit.go | 10 +- pkg/cmd/roachtest/tests/rebalance_load.go | 48 ++-- pkg/cmd/roachtest/tests/replicagc.go | 10 +- pkg/cmd/roachtest/tests/restart.go | 10 +- pkg/cmd/roachtest/tests/restore.go | 63 +++-- pkg/cmd/roachtest/tests/roachmart.go | 10 +- pkg/cmd/roachtest/tests/roachtest.go | 28 ++- pkg/cmd/roachtest/tests/ruby_pg.go | 14 +- pkg/cmd/roachtest/tests/rust_postgres.go | 12 +- pkg/cmd/roachtest/tests/schemachange.go | 50 ++-- .../tests/schemachange_random_load.go | 16 +- pkg/cmd/roachtest/tests/scrub.go | 12 +- pkg/cmd/roachtest/tests/secondary_indexes.go | 8 +- pkg/cmd/roachtest/tests/sequelize.go | 14 +- pkg/cmd/roachtest/tests/slow_drain.go | 10 +- pkg/cmd/roachtest/tests/smoketest_secure.go | 24 +- pkg/cmd/roachtest/tests/split.go | 112 +++++---- pkg/cmd/roachtest/tests/sqlalchemy.go | 12 +- pkg/cmd/roachtest/tests/sqlsmith.go | 16 +- pkg/cmd/roachtest/tests/sstable_corruption.go | 12 +- pkg/cmd/roachtest/tests/synctest.go | 6 +- pkg/cmd/roachtest/tests/sysbench.go | 8 +- pkg/cmd/roachtest/tests/tlp.go | 20 +- pkg/cmd/roachtest/tests/tpcc.go | 65 ++++- pkg/cmd/roachtest/tests/tpcdsvec.go | 10 +- pkg/cmd/roachtest/tests/tpce.go | 62 +++-- pkg/cmd/roachtest/tests/tpch_concurrency.go | 24 +- pkg/cmd/roachtest/tests/tpchbench.go | 10 +- pkg/cmd/roachtest/tests/tpchvec.go | 46 ++-- pkg/cmd/roachtest/tests/typeorm.go | 12 +- .../tests/unoptimized_query_oracle.go | 12 +- ...ate_system_schema_after_version_upgrade.go | 8 +- pkg/cmd/roachtest/tests/version.go | 8 +- pkg/cmd/roachtest/tests/ycsb.go | 10 +- 124 files changed, 1704 insertions(+), 861 deletions(-) create mode 100644 pkg/cmd/roachtest/registry/test_spec_test.go 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`), }) } }