forked from rook/rook
179 lines
6.9 KiB
Go
179 lines
6.9 KiB
Go
/*
|
|
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 osd
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/google/uuid"
|
|
rookalpha "github.com/rook/rook/pkg/apis/rook.io/v1alpha1"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestSchemeSaveLoad(t *testing.T) {
|
|
kv := mockKVStore()
|
|
storeName := getConfigStoreName("node123")
|
|
|
|
// loading the scheme when there is no scheme file should return an empty scheme with no error
|
|
scheme, err := LoadScheme(kv, storeName)
|
|
assert.Nil(t, err)
|
|
assert.NotNil(t, scheme)
|
|
assert.Equal(t, 0, len(scheme.Entries))
|
|
assert.Nil(t, scheme.Metadata)
|
|
|
|
// add some entries to the scheme
|
|
scheme.Metadata = NewMetadataDeviceInfo("sda")
|
|
scheme.Metadata.DiskUUID = uuid.Must(uuid.NewRandom()).String()
|
|
m1 := &MetadataDevicePartition{ID: 1, OsdUUID: uuid.Must(uuid.NewRandom()), Type: WalPartitionType,
|
|
PartitionUUID: uuid.Must(uuid.NewRandom()).String(), SizeMB: 100, OffsetMB: 1}
|
|
m2 := &MetadataDevicePartition{ID: 1, OsdUUID: m1.OsdUUID, Type: DatabasePartitionType,
|
|
PartitionUUID: uuid.Must(uuid.NewRandom()).String(), SizeMB: 200, OffsetMB: 101}
|
|
scheme.Metadata.Partitions = append(scheme.Metadata.Partitions, []*MetadataDevicePartition{m1, m2}...)
|
|
|
|
e1 := &PerfSchemeEntry{ID: 1, OsdUUID: m1.OsdUUID}
|
|
e1.Partitions = map[PartitionType]*PerfSchemePartitionDetails{
|
|
BlockPartitionType: {
|
|
Device: "sdb",
|
|
DiskUUID: uuid.Must(uuid.NewRandom()).String(),
|
|
PartitionUUID: uuid.Must(uuid.NewRandom()).String(),
|
|
SizeMB: -1,
|
|
OffsetMB: 1,
|
|
},
|
|
}
|
|
|
|
// save the scheme to disk, should be no error
|
|
err = scheme.SaveScheme(kv, storeName)
|
|
assert.Nil(t, err)
|
|
|
|
// now load the saved scheme, it should load an equal object to what was saved
|
|
savedScheme, err := LoadScheme(kv, storeName)
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, scheme, savedScheme)
|
|
}
|
|
|
|
func TestPopulateCollocatedPerfSchemeEntry(t *testing.T) {
|
|
entry := NewPerfSchemeEntry(Bluestore)
|
|
entry.ID = 10
|
|
entry.OsdUUID = uuid.Must(uuid.NewRandom())
|
|
err := PopulateCollocatedPerfSchemeEntry(entry, "sda", rookalpha.StoreConfig{WalSizeMB: 1, DatabaseSizeMB: 2})
|
|
assert.Nil(t, err)
|
|
|
|
// verify the populated collocated partition entries
|
|
assert.Equal(t, 3, len(entry.Partitions))
|
|
verifyPartitionDetails(t, entry, WalPartitionType, "sda", 1, 1)
|
|
verifyPartitionDetails(t, entry, DatabasePartitionType, "sda", 2, 2)
|
|
verifyPartitionDetails(t, entry, BlockPartitionType, "sda", 4, -1)
|
|
|
|
}
|
|
|
|
func TestPopulateDistributedPerfSchemeEntry(t *testing.T) {
|
|
metadata := NewMetadataDeviceInfo("sda")
|
|
|
|
entry := NewPerfSchemeEntry(Bluestore)
|
|
entry.ID = 20
|
|
entry.OsdUUID = uuid.Must(uuid.NewRandom())
|
|
|
|
err := PopulateDistributedPerfSchemeEntry(entry, "sdb", metadata, rookalpha.StoreConfig{WalSizeMB: 1, DatabaseSizeMB: 2})
|
|
assert.Nil(t, err)
|
|
|
|
// verify the populated distributed partition entries (metadata partitions should be on metadata device, block
|
|
// partition should be on its own device)
|
|
assert.Equal(t, 3, len(entry.Partitions))
|
|
verifyPartitionDetails(t, entry, WalPartitionType, "sda", 1, 1)
|
|
verifyPartitionDetails(t, entry, DatabasePartitionType, "sda", 2, 2)
|
|
verifyPartitionDetails(t, entry, BlockPartitionType, "sdb", 1, -1)
|
|
|
|
// verify that the metadata device info was populated as well
|
|
assert.Equal(t, 2, len(metadata.Partitions))
|
|
verifyMetadataDevicePartition(t, metadata, 0, entry.ID, entry.OsdUUID, WalPartitionType, 1, 1)
|
|
verifyMetadataDevicePartition(t, metadata, 1, entry.ID, entry.OsdUUID, DatabasePartitionType, 2, 2)
|
|
}
|
|
|
|
func verifyPartitionDetails(t *testing.T, entry *PerfSchemeEntry, partType PartitionType, device string, offset, size int) {
|
|
part, ok := entry.Partitions[partType]
|
|
assert.True(t, ok)
|
|
assert.NotNil(t, part)
|
|
assert.Equal(t, device, part.Device)
|
|
assert.Equal(t, offset, part.OffsetMB)
|
|
assert.Equal(t, size, part.SizeMB)
|
|
}
|
|
|
|
func verifyMetadataDevicePartition(t *testing.T, info *MetadataDeviceInfo, index int, osdID int, osdUUID uuid.UUID,
|
|
partType PartitionType, offset, size int) {
|
|
|
|
part := info.Partitions[index]
|
|
assert.NotNil(t, part)
|
|
assert.Equal(t, osdID, part.ID)
|
|
assert.Equal(t, osdUUID, part.OsdUUID)
|
|
assert.Equal(t, partType, part.Type)
|
|
assert.Equal(t, offset, part.OffsetMB)
|
|
assert.Equal(t, size, part.SizeMB)
|
|
}
|
|
|
|
func TestMetadataGetPartitionArgs(t *testing.T) {
|
|
metadata := NewMetadataDeviceInfo("sda")
|
|
|
|
e1 := NewPerfSchemeEntry(Bluestore)
|
|
e1.ID = 1
|
|
e1.OsdUUID = uuid.Must(uuid.NewRandom())
|
|
|
|
e2 := NewPerfSchemeEntry(Bluestore)
|
|
e2.ID = 2
|
|
e2.OsdUUID = uuid.Must(uuid.NewRandom())
|
|
|
|
storeConfig := rookalpha.StoreConfig{WalSizeMB: 1, DatabaseSizeMB: 2}
|
|
err := PopulateDistributedPerfSchemeEntry(e1, "sdb", metadata, storeConfig)
|
|
assert.Nil(t, err)
|
|
err = PopulateDistributedPerfSchemeEntry(e2, "sdc", metadata, storeConfig)
|
|
assert.Nil(t, err)
|
|
|
|
expectedArgs := []string{
|
|
"--new=1:2048:+2048", "--change-name=1:ROOK-OSD1-WAL", fmt.Sprintf("--partition-guid=1:%s", metadata.Partitions[0].PartitionUUID),
|
|
"--new=2:4096:+4096", "--change-name=2:ROOK-OSD1-DB", fmt.Sprintf("--partition-guid=2:%s", metadata.Partitions[1].PartitionUUID),
|
|
"--new=3:8192:+2048", "--change-name=3:ROOK-OSD2-WAL", fmt.Sprintf("--partition-guid=3:%s", metadata.Partitions[2].PartitionUUID),
|
|
"--new=4:10240:+4096", "--change-name=4:ROOK-OSD2-DB", fmt.Sprintf("--partition-guid=4:%s", metadata.Partitions[3].PartitionUUID),
|
|
fmt.Sprintf("--disk-guid=%s", metadata.DiskUUID), "/dev/sda",
|
|
}
|
|
|
|
// get the partition args and verify against expected
|
|
args := metadata.GetPartitionArgs()
|
|
assert.Equal(t, expectedArgs, args)
|
|
}
|
|
|
|
func TestSchemeEntryGetPartitionArgs(t *testing.T) {
|
|
e1 := NewPerfSchemeEntry(Bluestore)
|
|
e1.ID = 1
|
|
e1.OsdUUID = uuid.Must(uuid.NewRandom())
|
|
|
|
storeConfig := rookalpha.StoreConfig{WalSizeMB: 1, DatabaseSizeMB: 2}
|
|
err := PopulateCollocatedPerfSchemeEntry(e1, "sdb", storeConfig)
|
|
assert.Nil(t, err)
|
|
|
|
expectedArgs := []string{
|
|
"--new=1:2048:+2048", "--change-name=1:ROOK-OSD1-WAL", fmt.Sprintf("--partition-guid=1:%s", e1.Partitions[WalPartitionType].PartitionUUID),
|
|
"--new=2:4096:+4096", "--change-name=2:ROOK-OSD1-DB", fmt.Sprintf("--partition-guid=2:%s", e1.Partitions[DatabasePartitionType].PartitionUUID),
|
|
"--largest-new=3", "--change-name=3:ROOK-OSD1-BLOCK", fmt.Sprintf("--partition-guid=3:%s", e1.Partitions[BlockPartitionType].PartitionUUID),
|
|
fmt.Sprintf("--disk-guid=%s", e1.Partitions[BlockPartitionType].DiskUUID), "/dev/sdb",
|
|
}
|
|
|
|
// get the partition args and verify against expected
|
|
args := e1.GetPartitionArgs()
|
|
assert.Equal(t, expectedArgs, args)
|
|
|
|
logger.Noticef("%+v", args)
|
|
}
|