tests: Migrate alarm tests to common framework

tests/common/alarm_test.go

@@ -0,0 +1,103 @@
+// Copyright 2022 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package common
+
+import (
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	clientv3 "go.etcd.io/etcd/client/v3"
+	"go.etcd.io/etcd/tests/v3/framework/config"
+	"go.etcd.io/etcd/tests/v3/framework/testutils"
+)
+
+func TestAlarm(t *testing.T) {
+	testRunner.BeforeTest(t)
+	clus := testRunner.NewCluster(t, config.ClusterConfig{ClusterSize: 1, QuotaBackendBytes: int64(13 * os.Getpagesize())})
+	defer clus.Close()
+	testutils.ExecuteWithTimeout(t, 10*time.Second, func() {
+		// test small put still works
+		smallbuf := strings.Repeat("a", 64)
+		if err := clus.Client().Put("1st_test", smallbuf, config.PutOptions{}); err != nil {
+			t.Fatalf("alarmTest: put kv error (%v)", err)
+		}
+
+		// write some chunks to fill up the database
+		buf := strings.Repeat("b", os.Getpagesize())
+		for {
+			if err := clus.Client().Put("2nd_test", buf, config.PutOptions{}); err != nil {
+				if !strings.Contains(err.Error(), "etcdserver: mvcc: database space exceeded") {
+					t.Fatal(err)
+				}
+				break
+			}
+		}
+
+		// quota alarm should now be on
+		alarmResp, err := clus.Client().AlarmList()
+		if err != nil {
+			t.Fatalf("alarmTest: Alarm error (%v)", err)
+		}
+
+		// check that Put is rejected when alarm is on
+		if err := clus.Client().Put("3rd_test", smallbuf, config.PutOptions{}); err != nil {
+			if !strings.Contains(err.Error(), "etcdserver: mvcc: database space exceeded") {
+				t.Fatal(err)
+			}
+		}
+
+		// get latest revision to compact
+		sresp, err := clus.Client().Status()
+		if err != nil {
+			t.Fatalf("get endpoint status error: %v", err)
+		}
+		var rvs int64
+		for _, resp := range sresp {
+			if resp != nil && resp.Header != nil {
+				rvs = resp.Header.Revision
+				break
+			}
+		}
+
+		// make some space
+		_, err = clus.Client().Compact(rvs, config.CompactOption{Physical: true, Timeout: 10 * time.Second})
+		if err != nil {
+			t.Fatalf("alarmTest: Compact error (%v)", err)
+		}
+
+		if err = clus.Client().Defragment(config.DefragOption{Timeout: 10 * time.Second}); err != nil {
+			t.Fatalf("alarmTest: defrag error (%v)", err)
+		}
+
+		// turn off alarm
+		for _, alarm := range alarmResp.Alarms {
+			alarmMember := &clientv3.AlarmMember{
+				MemberID: alarm.MemberID,
+				Alarm:    alarm.Alarm,
+			}
+			_, err = clus.Client().AlarmDisarm(alarmMember)
+			if err != nil {
+				t.Fatalf("alarmTest: Alarm error (%v)", err)
+			}
+		}
+
+		// put one more key below quota
+		if err := clus.Client().Put("4th_test", smallbuf, config.PutOptions{}); err != nil {
+			t.Fatal(err)
+		}
+	})
+}

tests/e2e/ctl_v3_test.go

@@ -181,10 +181,6 @@ func withQuota(b int64) ctlOption {
 	return func(cx *ctlCtx) { cx.quotaBackendBytes = b }
 }
 
-func withCompactPhysical() ctlOption {
-	return func(cx *ctlCtx) { cx.compactPhysical = true }
-}
-
 func withInitialCorruptCheck() ctlOption {
 	return func(cx *ctlCtx) { cx.initialCorruptCheck = true }
 }

tests/framework/config/cluster.go

@@ -23,7 +23,8 @@ const (
 )
 
 type ClusterConfig struct {
-	ClusterSize int
-	PeerTLS     TLSConfig
-	ClientTLS   TLSConfig
+	ClusterSize       int
+	PeerTLS           TLSConfig
+	ClientTLS         TLSConfig
+	QuotaBackendBytes int64
 }

tests/framework/e2e.go

@@ -40,8 +40,9 @@ func (e e2eRunner) BeforeTest(t testing.TB) {
 
 func (e e2eRunner) NewCluster(t testing.TB, cfg config.ClusterConfig) Cluster {
 	e2eConfig := e2e.EtcdProcessClusterConfig{
-		InitialToken: "new",
-		ClusterSize:  cfg.ClusterSize,
+		InitialToken:      "new",
+		ClusterSize:       cfg.ClusterSize,
+		QuotaBackendBytes: cfg.QuotaBackendBytes,
 	}
 	switch cfg.ClientTLS {
 	case config.NoTLS:

tests/framework/e2e/etcdctl.go

@@ -343,3 +343,35 @@ func (ctl *EtcdctlV3) LeaseRevoke(id clientv3.LeaseID) (*clientv3.LeaseRevokeRes
 	err = json.Unmarshal([]byte(line), &resp)
 	return &resp, err
 }
+
+func (ctl *EtcdctlV3) AlarmList() (*clientv3.AlarmResponse, error) {
+	args := ctl.cmdArgs()
+	args = append(args, "alarm", "list", "-w", "json")
+	ep, err := SpawnCmd(args, nil)
+	if err != nil {
+		return nil, err
+	}
+	var resp clientv3.AlarmResponse
+	line, err := ep.Expect("alarm")
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal([]byte(line), &resp)
+	return &resp, err
+}
+
+func (ctl *EtcdctlV3) AlarmDisarm(_ *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) {
+	args := ctl.cmdArgs()
+	args = append(args, "alarm", "disarm", "-w", "json")
+	ep, err := SpawnCmd(args, nil)
+	if err != nil {
+		return nil, err
+	}
+	var resp clientv3.AlarmResponse
+	line, err := ep.Expect("alarm")
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal([]byte(line), &resp)
+	return &resp, err
+}

tests/framework/integration.go

@@ -45,6 +45,7 @@ func (e integrationRunner) NewCluster(t testing.TB, cfg config.ClusterConfig) Cl
 	var integrationCfg integration.ClusterConfig
 	integrationCfg.Size = cfg.ClusterSize
 	integrationCfg.ClientTLS, err = tlsInfo(t, cfg.ClientTLS)
+	integrationCfg.QuotaBackendBytes = cfg.QuotaBackendBytes
 	if err != nil {
 		t.Fatalf("ClientTLS: %s", err)
 	}
@@ -163,6 +164,14 @@ func (c integrationClient) Compact(rev int64, o config.CompactOption) (*clientv3
 	return c.Client.Compact(ctx, rev, clientOpts...)
 }
 
+func (c integrationClient) AlarmList() (*clientv3.AlarmResponse, error) {
+	return c.Client.AlarmList(context.Background())
+}
+
+func (c integrationClient) AlarmDisarm(alarmMember *clientv3.AlarmMember) (*clientv3.AlarmResponse, error) {
+	return c.Client.AlarmDisarm(context.Background(), alarmMember)
+}
+
 func (c integrationClient) Status() ([]*clientv3.StatusResponse, error) {
 	endpoints := c.Client.Endpoints()
 	var resp []*clientv3.StatusResponse

tests/framework/interface.go

@@ -41,6 +41,8 @@ type Client interface {
 	HashKV(rev int64) ([]*clientv3.HashKVResponse, error)
 	Health() error
 	Defragment(opts config.DefragOption) error
+	AlarmList() (*clientv3.AlarmResponse, error)
+	AlarmDisarm(alarmMember *clientv3.AlarmMember) (*clientv3.AlarmResponse, error)
 	Grant(ttl int64) (*clientv3.LeaseGrantResponse, error)
 	TimeToLive(id clientv3.LeaseID, opts config.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error)
 	LeaseList() (*clientv3.LeaseLeasesResponse, error)