ceph-csi/internal/rbd/group/util.go
Niels de Vos 689498e66a rbd: move common functions for VolumeGroup structs into own type
Many functions that are implemented for the volumeGroup type can be
shared with the (coming) volumeGroupSnapshot type. Move these functions
into a commonVolumeGroup type, so that volumeGroup and
volumeGroupSnapshot can inherit them.

Signed-off-by: Niels de Vos <ndevos@ibm.com>
2024-08-28 11:46:29 +00:00

249 lines
6.8 KiB
Go

/*
Copyright 2024 The Ceph-CSI 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 group
import (
"context"
"errors"
"fmt"
"time"
"github.com/ceph/go-ceph/rados"
"github.com/ceph/ceph-csi/internal/journal"
"github.com/ceph/ceph-csi/internal/util"
"github.com/ceph/ceph-csi/internal/util/log"
)
type commonVolumeGroup struct {
// id is a unique value for this volume group in the Ceph cluster, it
// is used to find the group in the journal.
id string
// name is used in RBD API calls as the name of this object
name string
// creationTime is the time the group was created
creationTime *time.Time
clusterID string
objectUUID string
credentials *util.Credentials
// temporary connection attributes
conn *util.ClusterConnection
ioctx *rados.IOContext
// required details to perform operations on the group
monitors string
pool string
namespace string
journal journal.VolumeGroupJournal
}
func (cvg *commonVolumeGroup) initCommonVolumeGroup(
ctx context.Context,
id string,
j journal.VolumeGroupJournal,
creds *util.Credentials,
) error {
csiID := util.CSIIdentifier{}
err := csiID.DecomposeCSIID(id)
if err != nil {
return fmt.Errorf("failed to decompose volume group id %q: %w", id, err)
}
mons, err := util.Mons(util.CsiConfigFile, csiID.ClusterID)
if err != nil {
return fmt.Errorf("failed to get MONs for cluster id %q: %w", csiID.ClusterID, err)
}
namespace, err := util.GetRadosNamespace(util.CsiConfigFile, csiID.ClusterID)
if err != nil {
return fmt.Errorf("failed to get RADOS namespace for cluster id %q: %w", csiID.ClusterID, err)
}
pool, err := util.GetPoolName(mons, creds, csiID.LocationID)
if err != nil {
return fmt.Errorf("failed to get pool for volume group id %q: %w", id, err)
}
cvg.journal = j
cvg.credentials = creds
cvg.id = id
cvg.clusterID = csiID.ClusterID
cvg.objectUUID = csiID.ObjectUUID
cvg.monitors = mons
cvg.pool = pool
cvg.namespace = namespace
log.DebugLog(ctx, "object for volume group %q has been initialized", cvg.id)
return nil
}
func (cvg *commonVolumeGroup) Destroy(ctx context.Context) {
if cvg.ioctx != nil {
cvg.ioctx.Destroy()
cvg.ioctx = nil
}
if cvg.conn != nil {
cvg.conn.Destroy()
cvg.conn = nil
}
if cvg.credentials != nil {
cvg.credentials.DeleteCredentials()
cvg.credentials = nil
}
log.DebugLog(ctx, "destroyed volume group instance with id %q", cvg.id)
}
// getVolumeGroupAttributes fetches the attributes from the journal, sets some
// of the common values for the VolumeGroup and returns the attributes struct
// for further consumption (like checking the VolumeMap).
func (cvg *commonVolumeGroup) getVolumeGroupAttributes(ctx context.Context) (*journal.VolumeGroupAttributes, error) {
attrs, err := cvg.journal.GetVolumeGroupAttributes(ctx, cvg.pool, cvg.objectUUID)
if err != nil {
if !errors.Is(err, util.ErrKeyNotFound) && !errors.Is(err, util.ErrPoolNotFound) {
return nil, fmt.Errorf("failed to get attributes for volume group id %q: %w", cvg.id, err)
}
attrs = &journal.VolumeGroupAttributes{}
}
cvg.name = attrs.GroupName
cvg.creationTime = attrs.CreationTime
return attrs, nil
}
// String returns the image-spec (pool/{namespace}/{name}) format of the group.
func (cvg *commonVolumeGroup) String() string {
if cvg.namespace != "" && cvg.pool != "" && cvg.name != "" {
return fmt.Sprintf("%s/%s/%s", cvg.pool, cvg.namespace, cvg.name)
}
if cvg.name != "" && cvg.pool != "" {
return fmt.Sprintf("%s/%s", cvg.pool, cvg.name)
}
return fmt.Sprintf("<unidentified group %v>", *cvg)
}
// GetID returns the CSI-Addons VolumeGroupId of the VolumeGroup.
func (cvg *commonVolumeGroup) GetID(ctx context.Context) (string, error) {
if cvg.id == "" {
return "", errors.New("BUG: ID is not set")
}
return cvg.id, nil
}
// GetName returns the name in the backend storage for the VolumeGroup.
func (cvg *commonVolumeGroup) GetName(ctx context.Context) (string, error) {
if cvg.name == "" {
return "", errors.New("BUG: name is not set")
}
return cvg.name, nil
}
// GetPool returns the name of the pool that holds the VolumeGroup.
func (cvg *commonVolumeGroup) GetPool(ctx context.Context) (string, error) {
if cvg.pool == "" {
return "", errors.New("BUG: pool is not set")
}
return cvg.pool, nil
}
// GetClusterID returns the name of the pool that holds the VolumeGroup.
func (cvg *commonVolumeGroup) GetClusterID(ctx context.Context) (string, error) {
if cvg.clusterID == "" {
return "", errors.New("BUG: clusterID is not set")
}
return cvg.clusterID, nil
}
// getConnection returns the ClusterConnection for the volume group if it
// exists, otherwise it will open a new one.
// Destroy should be used to close the ClusterConnection.
func (cvg *commonVolumeGroup) getConnection(ctx context.Context) (*util.ClusterConnection, error) {
if cvg.conn != nil {
return cvg.conn, nil
}
conn := &util.ClusterConnection{}
err := conn.Connect(cvg.monitors, cvg.credentials)
if err != nil {
return nil, fmt.Errorf("failed to connect to MONs %q: %w", cvg.monitors, err)
}
cvg.conn = conn
log.DebugLog(ctx, "connection established for volume group %q", cvg.id)
return conn, nil
}
// GetIOContext returns the IOContext for the volume group if it exists,
// otherwise it will allocate a new one.
// Destroy should be used to free the IOContext.
func (cvg *commonVolumeGroup) GetIOContext(ctx context.Context) (*rados.IOContext, error) {
if cvg.ioctx != nil {
return cvg.ioctx, nil
}
conn, err := cvg.getConnection(ctx)
if err != nil {
return nil, fmt.Errorf("%w: failed to connect: %w", ErrRBDGroupNotConnected, err)
}
ioctx, err := conn.GetIoctx(cvg.pool)
if err != nil {
return nil, fmt.Errorf("%w: failed to get IOContext: %w", ErrRBDGroupNotConnected, err)
}
if cvg.namespace != "" {
ioctx.SetNamespace(cvg.namespace)
}
cvg.ioctx = ioctx
log.DebugLog(ctx, "iocontext created for volume group %q in pool %q", cvg.id, cvg.pool)
return ioctx, nil
}
// GetCreationTime fetches the creation time of the volume group from the
// journal and returns it.
func (cvg *commonVolumeGroup) GetCreationTime(ctx context.Context) (*time.Time, error) {
if cvg.creationTime == nil {
// getVolumeGroupAttributes sets .creationTime (and a few other attributes)
_, err := cvg.getVolumeGroupAttributes(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get volume attributes for id %q: %w", cvg, err)
}
}
return cvg.creationTime, nil
}