go-ceph/cephfs/admin/subvolume_test.go

636 lines
17 KiB
Go

// +build !luminous,!mimic
package admin
import (
"errors"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func delay() {
// ceph seems to do this (partly?) async. So for now, we cheat
// and sleep a little to make subsequent tests more reliable
time.Sleep(50 * time.Millisecond)
}
func TestCreateSubVolume(t *testing.T) {
fsa := getFSAdmin(t)
volume := "cephfs"
type gn struct {
group string
name string
}
created := []gn{}
defer func() {
for _, c := range created {
err := fsa.RemoveSubVolume(volume, c.group, c.name)
assert.NoError(t, err)
delay()
if c.group != NoGroup {
err := fsa.RemoveSubVolumeGroup(volume, c.group)
assert.NoError(t, err)
}
}
}()
t.Run("simple", func(t *testing.T) {
subname := "SubVol1"
err := fsa.CreateSubVolume(volume, NoGroup, subname, nil)
assert.NoError(t, err)
created = append(created, gn{NoGroup, subname})
lsv, err := fsa.ListSubVolumes(volume, NoGroup)
assert.NoError(t, err)
assert.GreaterOrEqual(t, len(lsv), 1)
assert.Contains(t, lsv, subname)
})
t.Run("options", func(t *testing.T) {
subname := "SubVol2"
o := &SubVolumeOptions{
Mode: 0777,
Uid: 200,
Gid: 200,
}
err := fsa.CreateSubVolume(volume, NoGroup, subname, o)
assert.NoError(t, err)
created = append(created, gn{NoGroup, subname})
lsv, err := fsa.ListSubVolumes(volume, NoGroup)
assert.NoError(t, err)
assert.GreaterOrEqual(t, len(lsv), 1)
assert.Contains(t, lsv, subname)
})
t.Run("withGroup", func(t *testing.T) {
group := "withGroup1"
subname := "SubVol3"
err := fsa.CreateSubVolumeGroup(volume, group, nil)
assert.NoError(t, err)
err = fsa.CreateSubVolume(volume, group, subname, nil)
assert.NoError(t, err)
created = append(created, gn{group, subname})
lsv, err := fsa.ListSubVolumes(volume, group)
assert.NoError(t, err)
assert.GreaterOrEqual(t, len(lsv), 1)
assert.Contains(t, lsv, subname)
})
t.Run("groupAndOptions", func(t *testing.T) {
group := "withGroup2"
subname := "SubVol4"
err := fsa.CreateSubVolumeGroup(volume, group, nil)
assert.NoError(t, err)
o := &SubVolumeOptions{
Size: 5 * gibiByte,
Mode: 0777,
Uid: 200,
Gid: 200,
}
err = fsa.CreateSubVolume(volume, group, subname, o)
assert.NoError(t, err)
created = append(created, gn{group, subname})
lsv, err := fsa.ListSubVolumes(volume, group)
assert.NoError(t, err)
assert.GreaterOrEqual(t, len(lsv), 1)
assert.Contains(t, lsv, subname)
})
}
func TestRemoveSubVolume(t *testing.T) {
fsa := getFSAdmin(t)
volume := "cephfs"
lsv, err := fsa.ListSubVolumes(volume, NoGroup)
assert.NoError(t, err)
beforeCount := len(lsv)
removeTest := func(t *testing.T, rm func(string, string, string) error) {
err = fsa.CreateSubVolume(volume, NoGroup, "deletemev1", nil)
assert.NoError(t, err)
lsv, err = fsa.ListSubVolumes(volume, NoGroup)
assert.NoError(t, err)
afterCount := len(lsv)
assert.Equal(t, beforeCount, afterCount-1)
err = rm(volume, NoGroup, "deletemev1")
assert.NoError(t, err)
delay()
lsv, err = fsa.ListSubVolumes(volume, NoGroup)
assert.NoError(t, err)
nowCount := len(lsv)
if !assert.Equal(t, beforeCount, nowCount) {
// this is a hack for debugging a flapping test
assert.Equal(t, []string{}, lsv)
}
}
t.Run("standard", func(t *testing.T) {
removeTest(t, fsa.RemoveSubVolume)
})
t.Run("force", func(t *testing.T) {
removeTest(t, fsa.ForceRemoveSubVolume)
})
t.Run("withFlagsEmpty", func(t *testing.T) {
removeTest(t, func(v, g, n string) error {
return fsa.RemoveSubVolumeWithFlags(v, g, n, SubVolRmFlags{})
})
})
t.Run("withFlagsForce", func(t *testing.T) {
removeTest(t, func(v, g, n string) error {
return fsa.RemoveSubVolumeWithFlags(v, g, n, SubVolRmFlags{Force: true})
})
})
t.Run("withFlagsRetainSnaps", func(t *testing.T) {
removeTest(t, func(v, g, n string) error {
return fsa.RemoveSubVolumeWithFlags(v, g, n, SubVolRmFlags{RetainSnapshots: true})
})
})
t.Run("retainedSnapshotsTest", func(t *testing.T) {
subname := "retsnap1"
snapname := "s1"
err = fsa.CreateSubVolume(volume, NoGroup, subname, nil)
assert.NoError(t, err)
vinfo, err := fsa.SubVolumeInfo(volume, NoGroup, subname)
assert.NoError(t, err)
canRetain := false
for _, f := range vinfo.Features {
if f == SnapshotRetentionFeature {
canRetain = true
}
}
if !canRetain {
err = fsa.RemoveSubVolumeWithFlags(
volume, NoGroup, subname, SubVolRmFlags{Force: true})
assert.NoError(t, err)
t.Skipf("this rest of this test requires snapshot retention on the server side")
}
lsv, err = fsa.ListSubVolumes(volume, NoGroup)
assert.NoError(t, err)
afterCount := len(lsv)
assert.Equal(t, beforeCount, afterCount-1)
err = fsa.CreateSubVolumeSnapshot(volume, NoGroup, subname, snapname)
err = fsa.RemoveSubVolumeWithFlags(
volume, NoGroup, subname, SubVolRmFlags{Force: true})
assert.Error(t, err)
err = fsa.RemoveSubVolumeWithFlags(
volume, NoGroup, subname, SubVolRmFlags{RetainSnapshots: true})
assert.NoError(t, err)
delay()
_, err = fsa.SubVolumeInfo(volume, NoGroup, subname)
assert.NoError(t, err)
err = fsa.RemoveSubVolumeSnapshot(volume, NoGroup, subname, snapname)
assert.NoError(t, err)
err = fsa.RemoveSubVolumeWithFlags(
volume, NoGroup, subname, SubVolRmFlags{Force: true})
assert.NoError(t, err)
// this seems to take longer than other removals. Try a few times to
// verify the subvolume is gone before asserting that the test failed
removed := false
for i := 0; i < 100; i++ {
delay()
lsv, err = fsa.ListSubVolumes(volume, NoGroup)
assert.NoError(t, err)
nowCount := len(lsv)
if nowCount == beforeCount {
removed = true
break
}
}
assert.True(t, removed, "volume count did not return to previous value")
})
}
func TestResizeSubVolume(t *testing.T) {
fsa := getFSAdmin(t)
volume := "cephfs"
group := "sizedGroup"
subname := "sizeMe1"
err := fsa.CreateSubVolumeGroup(volume, group, nil)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeGroup(volume, group)
assert.NoError(t, err)
}()
svopts := &SubVolumeOptions{
Mode: 0777,
Size: 20 * gibiByte,
}
err = fsa.CreateSubVolume(volume, group, subname, svopts)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolume(volume, group, subname)
assert.NoError(t, err)
}()
lsv, err := fsa.ListSubVolumes(volume, group)
assert.NoError(t, err)
assert.Contains(t, lsv, subname)
rr, err := fsa.ResizeSubVolume(volume, group, subname, 30*gibiByte, false)
assert.NoError(t, err)
assert.NotNil(t, rr)
rr, err = fsa.ResizeSubVolume(volume, group, subname, 10*gibiByte, true)
assert.NoError(t, err)
assert.NotNil(t, rr)
rr, err = fsa.ResizeSubVolume(volume, group, subname, Infinite, true)
assert.NoError(t, err)
assert.NotNil(t, rr)
}
func TestSubVolumePath(t *testing.T) {
fsa := getFSAdmin(t)
volume := "cephfs"
group := "svpGroup"
subname := "svp1"
err := fsa.CreateSubVolumeGroup(volume, group, nil)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeGroup(volume, group)
assert.NoError(t, err)
}()
err = fsa.CreateSubVolume(volume, group, subname, nil)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolume(volume, group, subname)
assert.NoError(t, err)
}()
path, err := fsa.SubVolumePath(volume, group, subname)
assert.NoError(t, err)
assert.Contains(t, path, group)
assert.Contains(t, path, subname)
assert.NotContains(t, path, "\n")
// invalid subname
path, err = fsa.SubVolumePath(volume, group, "oops")
assert.Error(t, err)
assert.Equal(t, "", path)
}
var sampleSubVolumeInfo1 = []byte(`
{
"atime": "2020-08-31 19:53:43",
"bytes_pcent": "undefined",
"bytes_quota": "infinite",
"bytes_used": 0,
"created_at": "2020-08-31 19:53:43",
"ctime": "2020-08-31 19:57:15",
"data_pool": "cephfs_data",
"gid": 0,
"mode": 16877,
"mon_addrs": [
"127.0.0.1:6789"
],
"mtime": "2020-08-31 19:53:43",
"path": "/volumes/_nogroup/nibbles/df11be81-a648-4a7b-8549-f28306e3ad93",
"pool_namespace": "",
"type": "subvolume",
"uid": 0
}
`)
var sampleSubVolumeInfo2 = []byte(`
{
"atime": "2020-09-01 17:49:25",
"bytes_pcent": "0.00",
"bytes_quota": 444444,
"bytes_used": 0,
"created_at": "2020-09-01 17:49:25",
"ctime": "2020-09-01 23:49:22",
"data_pool": "cephfs_data",
"gid": 0,
"mode": 16877,
"mon_addrs": [
"127.0.0.1:6789"
],
"mtime": "2020-09-01 17:49:25",
"path": "/volumes/_nogroup/nibbles/d6e062df-7fa0-46ca-872a-9adf728e0e00",
"pool_namespace": "",
"type": "subvolume",
"uid": 0
}
`)
var sampleSubVolumeInfo3 = []byte(`
{
"atime": "2020-10-02 13:48:17",
"bytes_pcent": "undefined",
"bytes_quota": "infinite",
"bytes_used": 0,
"created_at": "2020-10-02 13:48:17",
"ctime": "2020-10-02 13:48:17",
"data_pool": "cephfs_data",
"features": [
"snapshot-clone",
"snapshot-autoprotect"
],
"gid": 0,
"mode": 16877,
"mon_addrs": [
"127.0.0.1:6789"
],
"mtime": "2020-10-02 13:48:17",
"path": "/volumes/igotta/boogie/0302e067-e7fb-4d9b-8388-aae46164d8b0",
"pool_namespace": "",
"type": "subvolume",
"uid": 0
}
`)
var badSampleSubVolumeInfo1 = []byte(`
{
"bytes_quota": "fishy",
"uid": 0
}
`)
var badSampleSubVolumeInfo2 = []byte(`
{
"bytes_quota": true,
"uid": 0
}
`)
func TestParseSubVolumeInfo(t *testing.T) {
R := newResponse
t.Run("error", func(t *testing.T) {
_, err := parseSubVolumeInfo(R(nil, "", errors.New("gleep glop")))
assert.Error(t, err)
assert.Equal(t, "gleep glop", err.Error())
})
t.Run("statusSet", func(t *testing.T) {
_, err := parseSubVolumeInfo(R(nil, "unexpected!", nil))
assert.Error(t, err)
})
t.Run("ok", func(t *testing.T) {
info, err := parseSubVolumeInfo(R(sampleSubVolumeInfo1, "", nil))
assert.NoError(t, err)
if assert.NotNil(t, info) {
assert.Equal(t,
"/volumes/_nogroup/nibbles/df11be81-a648-4a7b-8549-f28306e3ad93",
info.Path)
assert.Equal(t, 0, info.Uid)
assert.Equal(t, Infinite, info.BytesQuota)
assert.Equal(t, 040755, info.Mode)
assert.Equal(t, 2020, info.Ctime.Year())
assert.Equal(t, "2020-08-31 19:57:15", info.Ctime.String())
}
})
t.Run("ok2", func(t *testing.T) {
info, err := parseSubVolumeInfo(R(sampleSubVolumeInfo2, "", nil))
assert.NoError(t, err)
if assert.NotNil(t, info) {
assert.Equal(t,
"/volumes/_nogroup/nibbles/d6e062df-7fa0-46ca-872a-9adf728e0e00",
info.Path)
assert.Equal(t, 0, info.Uid)
assert.Equal(t, ByteCount(444444), info.BytesQuota)
assert.Equal(t, 040755, info.Mode)
assert.Equal(t, 2020, info.Ctime.Year())
assert.Equal(t, "2020-09-01 23:49:22", info.Ctime.String())
}
})
t.Run("ok3", func(t *testing.T) {
info, err := parseSubVolumeInfo(R(sampleSubVolumeInfo3, "", nil))
assert.NoError(t, err)
if assert.NotNil(t, info) {
assert.Equal(t,
"/volumes/igotta/boogie/0302e067-e7fb-4d9b-8388-aae46164d8b0",
info.Path)
assert.Equal(t, 0, info.Uid)
assert.Equal(t, Infinite, info.BytesQuota)
assert.Equal(t, 040755, info.Mode)
assert.Equal(t, 2020, info.Ctime.Year())
assert.Equal(t, "2020-10-02 13:48:17", info.Ctime.String())
assert.Contains(t, info.Features, SnapshotCloneFeature)
assert.Contains(t, info.Features, SnapshotAutoprotectFeature)
}
})
t.Run("invalidBytesQuotaValue", func(t *testing.T) {
info, err := parseSubVolumeInfo(R(badSampleSubVolumeInfo1, "", nil))
assert.Error(t, err)
assert.Nil(t, info)
})
t.Run("invalidBytesQuotaType", func(t *testing.T) {
info, err := parseSubVolumeInfo(R(badSampleSubVolumeInfo2, "", nil))
assert.Error(t, err)
assert.Nil(t, info)
})
}
func TestSubVolumeInfo(t *testing.T) {
fsa := getFSAdmin(t)
volume := "cephfs"
group := "hoagie"
subname := "grinder"
err := fsa.CreateSubVolumeGroup(volume, group, nil)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeGroup(volume, group)
assert.NoError(t, err)
}()
svopts := &SubVolumeOptions{
Mode: 0750,
Size: 20 * gibiByte,
}
err = fsa.CreateSubVolume(volume, group, subname, svopts)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolume(volume, group, subname)
assert.NoError(t, err)
}()
vinfo, err := fsa.SubVolumeInfo(volume, group, subname)
assert.NoError(t, err)
assert.NotNil(t, vinfo)
assert.Equal(t, 0, vinfo.Uid)
assert.Equal(t, 20*gibiByte, vinfo.BytesQuota)
assert.Equal(t, 040750, vinfo.Mode)
assert.Equal(t, time.Now().Year(), vinfo.Ctime.Year())
}
func TestSubVolumeSnapshots(t *testing.T) {
fsa := getFSAdmin(t)
volume := "cephfs"
group := "20000leagues"
subname := "nautilus"
snapname1 := "ne1"
snapname2 := "mo2"
err := fsa.CreateSubVolumeGroup(volume, group, nil)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeGroup(volume, group)
assert.NoError(t, err)
}()
svopts := &SubVolumeOptions{
Mode: 0750,
Size: 20 * gibiByte,
}
err = fsa.CreateSubVolume(volume, group, subname, svopts)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolume(volume, group, subname)
assert.NoError(t, err)
}()
t.Run("createAndRemove", func(t *testing.T) {
err = fsa.CreateSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
err := fsa.RemoveSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
})
t.Run("createAndForceRemove", func(t *testing.T) {
err = fsa.CreateSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
err := fsa.ForceRemoveSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
})
t.Run("listOne", func(t *testing.T) {
err = fsa.CreateSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
}()
snaps, err := fsa.ListSubVolumeSnapshots(volume, group, subname)
assert.NoError(t, err)
assert.Len(t, snaps, 1)
assert.Contains(t, snaps, snapname1)
})
t.Run("listTwo", func(t *testing.T) {
err = fsa.CreateSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
}()
err = fsa.CreateSubVolumeSnapshot(volume, group, subname, snapname2)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeSnapshot(volume, group, subname, snapname2)
assert.NoError(t, err)
}()
snaps, err := fsa.ListSubVolumeSnapshots(volume, group, subname)
assert.NoError(t, err)
assert.Len(t, snaps, 2)
assert.Contains(t, snaps, snapname1)
assert.Contains(t, snaps, snapname2)
})
}
var sampleSubVolumeSnapshoInfo1 = []byte(`
{
"created_at": "2020-09-11 17:40:12.035792",
"data_pool": "cephfs_data",
"has_pending_clones": "no",
"protected": "yes",
"size": 0
}
`)
func TestParseSubVolumeSnapshotInfo(t *testing.T) {
R := newResponse
t.Run("error", func(t *testing.T) {
_, err := parseSubVolumeSnapshotInfo(R(nil, "", errors.New("flub")))
assert.Error(t, err)
assert.Equal(t, "flub", err.Error())
})
t.Run("statusSet", func(t *testing.T) {
_, err := parseSubVolumeSnapshotInfo(R(nil, "unexpected!", nil))
assert.Error(t, err)
})
t.Run("badJSON", func(t *testing.T) {
_, err := parseSubVolumeSnapshotInfo(R([]byte("_XxXxX"), "", nil))
assert.Error(t, err)
})
t.Run("ok", func(t *testing.T) {
info, err := parseSubVolumeSnapshotInfo(R(sampleSubVolumeSnapshoInfo1, "", nil))
assert.NoError(t, err)
if assert.NotNil(t, info) {
assert.Equal(t, "cephfs_data", info.DataPool)
assert.EqualValues(t, 0, info.Size)
assert.Equal(t, 2020, info.CreatedAt.Year())
assert.Equal(t, "yes", info.Protected)
assert.Equal(t, "no", info.HasPendingClones)
}
})
}
func TestSubVolumeSnapshotInfo(t *testing.T) {
fsa := getFSAdmin(t)
volume := "cephfs"
group := "20000leagues"
subname := "poulp"
snapname1 := "t1"
snapname2 := "nope"
err := fsa.CreateSubVolumeGroup(volume, group, nil)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeGroup(volume, group)
assert.NoError(t, err)
}()
svopts := &SubVolumeOptions{
Mode: 0750,
Size: 20 * gibiByte,
}
err = fsa.CreateSubVolume(volume, group, subname, svopts)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolume(volume, group, subname)
assert.NoError(t, err)
}()
err = fsa.CreateSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
defer func() {
err := fsa.RemoveSubVolumeSnapshot(volume, group, subname, snapname1)
assert.NoError(t, err)
}()
sinfo, err := fsa.SubVolumeSnapshotInfo(volume, group, subname, snapname1)
assert.NoError(t, err)
assert.NotNil(t, sinfo)
assert.EqualValues(t, 0, sinfo.Size)
assert.Equal(t, "cephfs_data", sinfo.DataPool)
assert.Equal(t, time.Now().Year(), sinfo.CreatedAt.Year())
sinfo, err = fsa.SubVolumeSnapshotInfo(volume, group, subname, snapname2)
assert.Error(t, err)
assert.Nil(t, sinfo)
}