Files
my-rook-config/pkg/operator/ceph/file/filesystem_test.go
T

526 lines
20 KiB
Go
Raw Normal View History

2017-03-09 15:24:33 -08:00
/*
Copyright 2016 The Rook Authors. All rights reserved.
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 file
2017-03-09 15:24:33 -08:00
import (
"context"
"encoding/json"
"errors"
2021-03-02 16:09:38 +01:00
"fmt"
"io/ioutil"
2017-03-09 15:24:33 -08:00
"os"
"path"
"reflect"
"strings"
2017-03-09 15:24:33 -08:00
"testing"
cephv1 "github.com/rook/rook/pkg/apis/ceph.rook.io/v1"
"github.com/rook/rook/pkg/clusterd"
2021-02-18 13:10:11 +00:00
cephclient "github.com/rook/rook/pkg/daemon/ceph/client"
clienttest "github.com/rook/rook/pkg/daemon/ceph/client/test"
2019-03-01 10:25:07 -07:00
"github.com/rook/rook/pkg/operator/ceph/file/mds"
2021-03-02 16:09:38 +01:00
"github.com/rook/rook/pkg/operator/ceph/version"
2021-02-18 13:10:11 +00:00
"github.com/rook/rook/pkg/operator/k8sutil"
testopk8s "github.com/rook/rook/pkg/operator/k8sutil/test"
2017-03-09 15:24:33 -08:00
testop "github.com/rook/rook/pkg/operator/test"
exectest "github.com/rook/rook/pkg/util/exec/test"
2017-03-09 15:24:33 -08:00
"github.com/stretchr/testify/assert"
2019-02-04 19:35:45 +00:00
apps "k8s.io/api/apps/v1"
2019-03-05 15:51:20 +01:00
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/resource"
2017-04-07 17:28:17 -07:00
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
2017-03-09 15:24:33 -08:00
)
func TestValidateSpec(t *testing.T) {
context := &clusterd.Context{Executor: &exectest.MockExecutor{}}
2021-04-09 03:59:41 -07:00
clusterInfo := &cephclient.ClusterInfo{Namespace: "ns"}
fs := &cephv1.CephFilesystem{}
2020-10-26 19:16:18 -06:00
clusterSpec := &cephv1.ClusterSpec{}
// missing name
2020-10-26 19:16:18 -06:00
assert.NotNil(t, validateFilesystem(context, clusterInfo, clusterSpec, fs))
fs.Name = "myfs"
// missing namespace
2020-10-26 19:16:18 -06:00
assert.NotNil(t, validateFilesystem(context, clusterInfo, clusterSpec, fs))
fs.Namespace = "myns"
// missing data pools
2020-10-26 19:16:18 -06:00
assert.NotNil(t, validateFilesystem(context, clusterInfo, clusterSpec, fs))
2020-02-20 11:37:09 +01:00
p := cephv1.PoolSpec{Replicated: cephv1.ReplicatedSpec{Size: 1, RequireSafeReplicaSize: false}}
fs.Spec.DataPools = append(fs.Spec.DataPools, p)
// missing metadata pool
2020-10-26 19:16:18 -06:00
assert.NotNil(t, validateFilesystem(context, clusterInfo, clusterSpec, fs))
fs.Spec.MetadataPool = p
// missing mds count
2020-10-26 19:16:18 -06:00
assert.NotNil(t, validateFilesystem(context, clusterInfo, clusterSpec, fs))
fs.Spec.MetadataServer.ActiveCount = 1
// valid!
2020-10-26 19:16:18 -06:00
assert.Nil(t, validateFilesystem(context, clusterInfo, clusterSpec, fs))
}
2021-03-02 16:09:38 +01:00
func isBasePoolOperation(fsName, command string, args []string) bool {
if reflect.DeepEqual(args[0:7], []string{"osd", "pool", "create", fsName + "-metadata", "0", "replicated", fsName + "-metadata"}) {
return true
} else if reflect.DeepEqual(args[0:5], []string{"osd", "crush", "rule", "create-replicated", fsName + "-metadata"}) {
return true
} else if reflect.DeepEqual(args[0:6], []string{"osd", "pool", "set", fsName + "-metadata", "size", "1"}) {
return true
} else if reflect.DeepEqual(args[0:7], []string{"osd", "pool", "create", fsName + "-data0", "0", "replicated", fsName + "-data0"}) {
return true
} else if reflect.DeepEqual(args[0:5], []string{"osd", "crush", "rule", "create-replicated", fsName + "-data0"}) {
return true
} else if reflect.DeepEqual(args[0:6], []string{"osd", "pool", "set", fsName + "-data0", "size", "1"}) {
return true
} else if reflect.DeepEqual(args[0:4], []string{"fs", "add_data_pool", fsName, fsName + "-data0"}) {
return true
}
return false
}
2021-09-21 09:13:09 +02:00
func fsExecutor(t *testing.T, fsName, configDir string, multiFS bool, createDataOnePoolCount, addDataOnePoolCount *int) *exectest.MockExecutor {
mdsmap := cephclient.CephFilesystemDetails{
ID: 0,
MDSMap: cephclient.MDSMap{
FilesystemName: fsName,
MetadataPool: 2,
MaxMDS: 1,
Up: map[string]int{
"mds_0": 123,
},
DataPools: []int{3},
Info: map[string]cephclient.MDSInfo{
"gid_123": {
GID: 123,
State: "up:active",
Name: fmt.Sprintf("%s-%s", fsName, "a"),
},
"gid_124": {
GID: 124,
State: "up:standby-replay",
Name: fmt.Sprintf("%s-%s", fsName, "b"),
},
},
},
}
createdFsResponse, _ := json.Marshal(mdsmap)
2021-03-02 16:09:38 +01:00
firstGet := true
2021-03-02 16:09:38 +01:00
if multiFS {
return &exectest.MockExecutor{
2021-07-21 11:25:52 +02:00
MockExecuteCommandWithOutput: func(command string, args ...string) (string, error) {
2021-03-02 16:09:38 +01:00
if contains(args, "fs") && contains(args, "get") {
if firstGet {
firstGet = false
return "", errors.New("fs doesn't exist")
}
return string(createdFsResponse), nil
2021-03-02 16:09:38 +01:00
} else if contains(args, "fs") && contains(args, "ls") {
return `[{"name":"myfs","metadata_pool":"myfs-metadata","metadata_pool_id":4,"data_pool_ids":[5],"data_pools":["myfs-data0"]},{"name":"myfs2","metadata_pool":"myfs2-metadata","metadata_pool_id":6,"data_pool_ids":[7],"data_pools":["myfs2-data0"]},{"name":"leseb","metadata_pool":"cephfs.leseb.meta","metadata_pool_id":8,"data_pool_ids":[9],"data_pools":["cephfs.leseb.data"]}]`, nil
2021-04-23 17:41:39 +08:00
} else if contains(args, "fs") && contains(args, "dump") {
return `{"standbys":[], "filesystems":[]}`, nil
2021-03-02 16:09:38 +01:00
} else if contains(args, "osd") && contains(args, "lspools") {
return "[]", nil
} else if contains(args, "mds") && contains(args, "fail") {
return "", nil
2021-03-02 16:09:38 +01:00
} else if isBasePoolOperation(fsName, command, args) {
return "", nil
} else if reflect.DeepEqual(args[0:5], []string{"fs", "new", fsName, fsName + "-metadata", fsName + "-data0"}) {
return "", nil
} else if contains(args, "auth") && contains(args, "get-or-create-key") {
return "{\"key\":\"mysecurekey\"}", nil
} else if contains(args, "auth") && contains(args, "del") {
return "", nil
} else if contains(args, "config") && contains(args, "get") {
return "{}", nil
2021-03-02 16:09:38 +01:00
} else if contains(args, "config") && contains(args, "mds_cache_memory_limit") {
return "", nil
} else if contains(args, "set") && contains(args, "max_mds") {
return "", nil
} else if contains(args, "set") && contains(args, "allow_standby_replay") {
return "", nil
2021-03-02 16:09:38 +01:00
} else if contains(args, "config") && contains(args, "mds_join_fs") {
return "", nil
} else if contains(args, "flag") && contains(args, "enable_multiple") {
return "", nil
2021-09-21 09:13:09 +02:00
} else if reflect.DeepEqual(args[0:5], []string{"osd", "crush", "rule", "create-replicated", fsName + "-data1"}) {
return "", nil
} else if reflect.DeepEqual(args[0:4], []string{"osd", "pool", "create", fsName + "-data1"}) {
*createDataOnePoolCount++
return "", nil
} else if reflect.DeepEqual(args[0:6], []string{"osd", "pool", "set", fsName + "-data1", "size", "1"}) {
return "", nil
} else if reflect.DeepEqual(args[0:4], []string{"fs", "add_data_pool", fsName, fsName + "-data1"}) {
*addDataOnePoolCount++
return "", nil
} else if contains(args, "versions") {
versionStr, _ := json.Marshal(
map[string]map[string]int{
"mds": {
"ceph version 16.0.0-4-g2f728b9 (2f728b952cf293dd7f809ad8a0f5b5d040c43010) pacific (stable)": 2,
},
})
return string(versionStr), nil
2021-07-21 11:25:52 +02:00
} else if strings.Contains(command, "ceph-authtool") {
2021-03-02 16:09:38 +01:00
err := clienttest.CreateConfigDir(path.Join(configDir, "ns"))
assert.Nil(t, err)
}
2021-07-21 11:25:52 +02:00
assert.Fail(t, fmt.Sprintf("Unexpected command %q %q", command, args))
2021-03-02 16:09:38 +01:00
return "", nil
},
}
}
2021-03-02 16:09:38 +01:00
return &exectest.MockExecutor{
2021-07-21 11:25:52 +02:00
MockExecuteCommandWithOutput: func(command string, args ...string) (string, error) {
if contains(args, "fs") && contains(args, "get") {
if firstGet {
firstGet = false
return "", errors.New("fs doesn't exist")
}
return string(createdFsResponse), nil
} else if contains(args, "fs") && contains(args, "ls") {
return "[]", nil
2021-04-23 17:41:39 +08:00
} else if contains(args, "fs") && contains(args, "dump") {
return `{"standbys":[], "filesystems":[]}`, nil
} else if contains(args, "osd") && contains(args, "lspools") {
return "[]", nil
} else if contains(args, "mds") && contains(args, "fail") {
return "", nil
2021-03-02 16:09:38 +01:00
} else if isBasePoolOperation(fsName, command, args) {
return "", nil
2021-03-02 16:09:38 +01:00
} else if reflect.DeepEqual(args[0:5], []string{"fs", "new", fsName, fsName + "-metadata", fsName + "-data0"}) {
return "", nil
} else if contains(args, "auth") && contains(args, "get-or-create-key") {
return "{\"key\":\"mysecurekey\"}", nil
} else if contains(args, "auth") && contains(args, "del") {
return "", nil
} else if contains(args, "config") && contains(args, "mds_cache_memory_limit") {
return "", nil
} else if contains(args, "set") && contains(args, "max_mds") {
return "", nil
} else if contains(args, "set") && contains(args, "allow_standby_replay") {
return "", nil
2021-03-02 16:09:38 +01:00
} else if contains(args, "config") && contains(args, "mds_join_fs") {
return "", nil
} else if contains(args, "config") && contains(args, "get") {
return "{}", nil
2021-09-21 09:13:09 +02:00
} else if reflect.DeepEqual(args[0:5], []string{"osd", "crush", "rule", "create-replicated", fsName + "-data1"}) {
return "", nil
} else if reflect.DeepEqual(args[0:4], []string{"osd", "pool", "create", fsName + "-data1"}) {
*createDataOnePoolCount++
return "", nil
} else if reflect.DeepEqual(args[0:6], []string{"osd", "pool", "set", fsName + "-data1", "size", "1"}) {
return "", nil
} else if reflect.DeepEqual(args[0:4], []string{"fs", "add_data_pool", fsName, fsName + "-data1"}) {
*addDataOnePoolCount++
return "", nil
} else if contains(args, "versions") {
versionStr, _ := json.Marshal(
map[string]map[string]int{
"mds": {
"ceph version 16.0.0-4-g2f728b9 (2f728b952cf293dd7f809ad8a0f5b5d040c43010) pacific (stable)": 2,
},
})
return string(versionStr), nil
2021-07-21 11:25:52 +02:00
} else if strings.Contains(command, "ceph-authtool") {
err := clienttest.CreateConfigDir(path.Join(configDir, "ns"))
2020-01-07 18:51:19 +05:30
assert.Nil(t, err)
}
2021-07-21 11:25:52 +02:00
assert.Fail(t, fmt.Sprintf("Unexpected command %q %q", command, args))
return "", nil
},
}
2021-03-02 16:09:38 +01:00
}
func fsTest(fsName string) cephv1.CephFilesystem {
return cephv1.CephFilesystem{
ObjectMeta: metav1.ObjectMeta{Name: fsName, Namespace: "ns"},
Spec: cephv1.FilesystemSpec{
2020-02-20 11:37:09 +01:00
MetadataPool: cephv1.PoolSpec{Replicated: cephv1.ReplicatedSpec{Size: 1, RequireSafeReplicaSize: false}},
DataPools: []cephv1.PoolSpec{{Replicated: cephv1.ReplicatedSpec{Size: 1, RequireSafeReplicaSize: false}}},
MetadataServer: cephv1.MetadataServerSpec{
2017-10-05 10:00:19 -07:00
ActiveCount: 1,
Resources: v1.ResourceRequirements{
Limits: v1.ResourceList{
2019-03-05 15:51:20 +01:00
v1.ResourceMemory: *resource.NewQuantity(4294967296, resource.BinarySI),
},
Requests: v1.ResourceList{
v1.ResourceMemory: *resource.NewQuantity(1337.0, resource.BinarySI),
},
},
2017-10-05 10:00:19 -07:00
},
},
}
2021-03-02 16:09:38 +01:00
}
func TestCreateFilesystem(t *testing.T) {
ctx := context.TODO()
var deploymentsUpdated *[]*apps.Deployment
mds.UpdateDeploymentAndWait, deploymentsUpdated = testopk8s.UpdateDeploymentAndWaitStub()
configDir, _ := ioutil.TempDir("", "")
fsName := "myfs"
2021-09-21 09:13:09 +02:00
addDataOnePoolCount := 0
createDataOnePoolCount := 0
executor := fsExecutor(t, fsName, configDir, false, &createDataOnePoolCount, &addDataOnePoolCount)
2021-03-02 16:09:38 +01:00
defer os.RemoveAll(configDir)
clientset := testop.New(t, 1)
context := &clusterd.Context{
Executor: executor,
ConfigDir: configDir,
Clientset: clientset}
fs := fsTest(fsName)
clusterInfo := &cephclient.ClusterInfo{FSID: "myfsid", CephVersion: version.Octopus, Context: ctx}
2021-02-18 13:10:11 +00:00
ownerInfo := cephclient.NewMinimumOwnerInfoWithOwnerRef()
2017-03-09 15:24:33 -08:00
2021-09-21 09:13:09 +02:00
t.Run("start basic filesystem", func(t *testing.T) {
// start a basic cluster
err := createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.Nil(t, err)
validateStart(ctx, t, context, fs)
assert.ElementsMatch(t, []string{}, testopk8s.DeploymentNamesUpdated(deploymentsUpdated))
testopk8s.ClearDeploymentsUpdated(deploymentsUpdated)
})
2021-09-21 09:13:09 +02:00
t.Run("start again should no-op", func(t *testing.T) {
err := createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.Nil(t, err)
validateStart(ctx, t, context, fs)
assert.ElementsMatch(t, []string{fmt.Sprintf("rook-ceph-mds-%s-a", fsName), fmt.Sprintf("rook-ceph-mds-%s-b", fsName)}, testopk8s.DeploymentNamesUpdated(deploymentsUpdated))
testopk8s.ClearDeploymentsUpdated(deploymentsUpdated)
})
2021-09-21 09:13:09 +02:00
t.Run("increasing the number of data pools should be successful.", func(t *testing.T) {
context = &clusterd.Context{
Executor: executor,
ConfigDir: configDir,
Clientset: clientset}
fs.Spec.DataPools = append(fs.Spec.DataPools, cephv1.PoolSpec{Replicated: cephv1.ReplicatedSpec{Size: 1, RequireSafeReplicaSize: false}})
err := createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.Nil(t, err)
validateStart(ctx, t, context, fs)
assert.ElementsMatch(t, []string{fmt.Sprintf("rook-ceph-mds-%s-a", fsName), fmt.Sprintf("rook-ceph-mds-%s-b", fsName)}, testopk8s.DeploymentNamesUpdated(deploymentsUpdated))
assert.Equal(t, 1, createDataOnePoolCount)
assert.Equal(t, 1, addDataOnePoolCount)
testopk8s.ClearDeploymentsUpdated(deploymentsUpdated)
})
2021-09-21 09:13:09 +02:00
t.Run("multiple filesystem creation", func(t *testing.T) {
context = &clusterd.Context{
Executor: fsExecutor(t, fsName, configDir, true, &createDataOnePoolCount, &addDataOnePoolCount),
ConfigDir: configDir,
Clientset: clientset,
}
2021-03-02 16:09:38 +01:00
2021-09-21 09:13:09 +02:00
// Create another filesystem which should fail
err := createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, &k8sutil.OwnerInfo{}, "/var/lib/rook/")
assert.Error(t, err)
assert.Equal(t, fmt.Sprintf("failed to create filesystem %q: multiple filesystems are only supported as of ceph pacific", fsName), err.Error())
})
2021-03-02 16:09:38 +01:00
2021-09-21 09:13:09 +02:00
t.Run("multi filesystem creation now works since ceph version is pacific", func(t *testing.T) {
clusterInfo.CephVersion = version.Pacific
err := createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.NoError(t, err)
})
}
func TestUpgradeFilesystem(t *testing.T) {
ctx := context.TODO()
var deploymentsUpdated *[]*apps.Deployment
mds.UpdateDeploymentAndWait, deploymentsUpdated = testopk8s.UpdateDeploymentAndWaitStub()
configDir, _ := ioutil.TempDir("", "")
fsName := "myfs"
2021-09-21 09:13:09 +02:00
addDataOnePoolCount := 0
createDataOnePoolCount := 0
executor := fsExecutor(t, fsName, configDir, false, &createDataOnePoolCount, &addDataOnePoolCount)
defer os.RemoveAll(configDir)
clientset := testop.New(t, 1)
context := &clusterd.Context{
Executor: executor,
ConfigDir: configDir,
Clientset: clientset}
fs := fsTest(fsName)
clusterInfo := &cephclient.ClusterInfo{FSID: "myfsid", CephVersion: version.Octopus, Context: ctx}
// start a basic cluster for upgrade
ownerInfo := cephclient.NewMinimumOwnerInfoWithOwnerRef()
err := createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.NoError(t, err)
validateStart(ctx, t, context, fs)
assert.ElementsMatch(t, []string{}, testopk8s.DeploymentNamesUpdated(deploymentsUpdated))
testopk8s.ClearDeploymentsUpdated(deploymentsUpdated)
// do upgrade
clusterInfo.CephVersion = version.Quincy
context = &clusterd.Context{
Executor: executor,
ConfigDir: configDir,
Clientset: clientset,
}
err = createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.NoError(t, err)
// test fail standby daemon failed
mdsmap := cephclient.CephFilesystemDetails{
ID: 0,
MDSMap: cephclient.MDSMap{
FilesystemName: fsName,
MetadataPool: 2,
MaxMDS: 1,
Up: map[string]int{
"mds_0": 123,
},
DataPools: []int{3},
Info: map[string]cephclient.MDSInfo{
"gid_123": {
GID: 123,
State: "up:active",
Name: fmt.Sprintf("%s-%s", fsName, "a"),
},
"gid_124": {
GID: 124,
State: "up:standby-replay",
Name: fmt.Sprintf("%s-%s", fsName, "b"),
},
},
},
}
createdFsResponse, _ := json.Marshal(mdsmap)
firstGet := false
2021-07-21 11:25:52 +02:00
executor.MockExecuteCommandWithOutput = func(command string, args ...string) (string, error) {
if contains(args, "fs") && contains(args, "get") {
if firstGet {
firstGet = false
return "", errors.New("fs doesn't exist")
}
return string(createdFsResponse), nil
} else if contains(args, "fs") && contains(args, "ls") {
return "[]", nil
2021-04-23 17:41:39 +08:00
} else if contains(args, "fs") && contains(args, "dump") {
return `{"standbys":[], "filesystems":[]}`, nil
} else if contains(args, "osd") && contains(args, "lspools") {
return "[]", nil
} else if contains(args, "mds") && contains(args, "fail") {
return "", errors.New("fail mds failed")
} else if isBasePoolOperation(fsName, command, args) {
return "", nil
} else if reflect.DeepEqual(args[0:5], []string{"fs", "new", fsName, fsName + "-metadata", fsName + "-data0"}) {
return "", nil
} else if contains(args, "auth") && contains(args, "get-or-create-key") {
return "{\"key\":\"mysecurekey\"}", nil
} else if contains(args, "auth") && contains(args, "del") {
return "", nil
} else if contains(args, "config") && contains(args, "mds_cache_memory_limit") {
return "", nil
} else if contains(args, "set") && contains(args, "max_mds") {
return "", nil
} else if contains(args, "set") && contains(args, "allow_standby_replay") {
return "", nil
} else if contains(args, "config") && contains(args, "mds_join_fs") {
return "", nil
} else if contains(args, "config") && contains(args, "get") {
return "{}", nil
} else if contains(args, "versions") {
versionStr, _ := json.Marshal(
map[string]map[string]int{
"mds": {
"ceph version 16.0.0-4-g2f728b9 (2f728b952cf293dd7f809ad8a0f5b5d040c43010) pacific (stable)": 2,
},
})
return string(versionStr), nil
}
assert.Fail(t, fmt.Sprintf("Unexpected command %q %q", command, args))
return "", nil
}
// do upgrade
clusterInfo.CephVersion = version.Quincy
context = &clusterd.Context{
Executor: executor,
ConfigDir: configDir,
Clientset: clientset,
}
err = createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.Error(t, err)
assert.Contains(t, err.Error(), "fail mds failed")
}
func TestCreateNopoolFilesystem(t *testing.T) {
ctx := context.TODO()
2020-01-07 18:51:19 +05:30
clientset := testop.New(t, 3)
configDir, _ := ioutil.TempDir("", "")
executor := &exectest.MockExecutor{
2020-03-18 11:53:33 -06:00
MockExecuteCommandWithOutput: func(command string, args ...string) (string, error) {
if strings.Contains(command, "ceph-authtool") {
err := clienttest.CreateConfigDir(path.Join(configDir, "ns"))
2020-01-07 18:51:19 +05:30
assert.Nil(t, err)
2021-07-21 11:25:52 +02:00
} else {
return "{\"key\":\"mysecurekey\"}", nil
}
2021-07-21 11:25:52 +02:00
return "", errors.New("unknown command error")
},
}
defer os.RemoveAll(configDir)
context := &clusterd.Context{
Executor: executor,
ConfigDir: configDir,
2020-01-07 18:51:19 +05:30
Clientset: clientset}
2018-12-03 23:48:40 -07:00
fs := cephv1.CephFilesystem{
ObjectMeta: metav1.ObjectMeta{Name: "myfs", Namespace: "ns"},
2018-12-03 23:48:40 -07:00
Spec: cephv1.FilesystemSpec{
MetadataServer: cephv1.MetadataServerSpec{
ActiveCount: 1,
},
},
}
clusterInfo := &cephclient.ClusterInfo{FSID: "myfsid", Context: ctx}
// start a basic cluster
2021-02-18 13:10:11 +00:00
ownerInfo := cephclient.NewMinimumOwnerInfoWithOwnerRef()
err := createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.Nil(t, err)
validateStart(ctx, t, context, fs)
// starting again should be a no-op
2021-02-18 13:10:11 +00:00
err = createFilesystem(context, clusterInfo, fs, &cephv1.ClusterSpec{}, ownerInfo, "/var/lib/rook/")
assert.Nil(t, err)
validateStart(ctx, t, context, fs)
}
func contains(arr []string, str string) bool {
for _, a := range arr {
if a == str {
return true
}
}
return false
2017-03-09 15:24:33 -08:00
}
func validateStart(ctx context.Context, t *testing.T, context *clusterd.Context, fs cephv1.CephFilesystem) {
2021-03-02 16:09:38 +01:00
r, err := context.Clientset.AppsV1().Deployments(fs.Namespace).Get(ctx, fmt.Sprintf("rook-ceph-mds-%s-a", fs.Name), metav1.GetOptions{})
2017-03-09 15:24:33 -08:00
assert.Nil(t, err)
2021-03-02 16:09:38 +01:00
assert.Equal(t, fmt.Sprintf("rook-ceph-mds-%s-a", fs.Name), r.Name)
2017-03-09 15:24:33 -08:00
2021-03-02 16:09:38 +01:00
r, err = context.Clientset.AppsV1().Deployments(fs.Namespace).Get(ctx, fmt.Sprintf("rook-ceph-mds-%s-b", fs.Name), metav1.GetOptions{})
assert.Nil(t, err)
2021-03-02 16:09:38 +01:00
assert.Equal(t, fmt.Sprintf("rook-ceph-mds-%s-b", fs.Name), r.Name)
2017-10-05 10:00:19 -07:00
}