mirror of
https://github.com/ceph/ceph-csi.git
synced 2024-11-17 20:00:23 +00:00
720ad4afeb
The timeout value in external-provisioner is fairly low. It's not uncommon that it times out and retries before the rbdplugin is done with CreateVolume. rbdplugin has to serialize calls and ensure that they are idempotent to deal with this.
584 lines
17 KiB
Go
584 lines
17 KiB
Go
/*
|
|
Copyright 2018 The Kubernetes 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 rbd
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/golang/glog"
|
|
"github.com/pkg/errors"
|
|
"k8s.io/apimachinery/pkg/util/sets"
|
|
"k8s.io/kubernetes/pkg/util/keymutex"
|
|
)
|
|
|
|
const (
|
|
imageWatcherStr = "watcher="
|
|
rbdImageFormat1 = "1"
|
|
rbdImageFormat2 = "2"
|
|
imageSizeStr = "size "
|
|
sizeDivStr = " MB in"
|
|
kubeLockMagic = "kubelet_lock_magic_"
|
|
// The following three values are used for 30 seconds timeout
|
|
// while waiting for RBD Watcher to expire.
|
|
rbdImageWatcherInitDelay = 1 * time.Second
|
|
rbdImageWatcherFactor = 1.4
|
|
rbdImageWatcherSteps = 10
|
|
rbdDefaultMounter = "rbd"
|
|
)
|
|
|
|
type rbdVolume struct {
|
|
VolName string `json:"volName"`
|
|
VolID string `json:"volID"`
|
|
Monitors string `json:"monitors"`
|
|
MonValueFromSecret string `json:"monValueFromSecret"`
|
|
Pool string `json:"pool"`
|
|
ImageFormat string `json:"imageFormat"`
|
|
ImageFeatures string `json:"imageFeatures"`
|
|
VolSize int64 `json:"volSize"`
|
|
AdminId string `json:"adminId"`
|
|
UserId string `json:"userId"`
|
|
Mounter string `json:"mounter"`
|
|
}
|
|
|
|
type rbdSnapshot struct {
|
|
SourceVolumeID string `json:"sourceVolumeID"`
|
|
VolName string `json:"volName"`
|
|
SnapName string `json:"snapName"`
|
|
SnapID string `json:"sanpID"`
|
|
Monitors string `json:"monitors"`
|
|
MonValueFromSecret string `json:"monValueFromSecret"`
|
|
Pool string `json:"pool"`
|
|
CreatedAt int64 `json:"createdAt"`
|
|
SizeBytes int64 `json:"sizeBytes"`
|
|
AdminId string `json:"adminId"`
|
|
UserId string `json:"userId"`
|
|
}
|
|
|
|
var (
|
|
// serializes operations based on "<rbd pool>/<rbd image>" as key
|
|
attachdetachMutex = keymutex.NewKeyMutex()
|
|
// serializes operations based on "volume name" as key
|
|
volumeNameMutex = keymutex.NewKeyMutex()
|
|
// serializes operations based on "volume id" as key
|
|
volumeIDMutex = keymutex.NewKeyMutex()
|
|
// serializes operations based on "snapshot name" as key
|
|
snapshotNameMutex = keymutex.NewKeyMutex()
|
|
// serializes operations based on "snapshot id" as key
|
|
snapshotIDMutex = keymutex.NewKeyMutex()
|
|
// serializes operations based on "mount target path" as key
|
|
targetPathMutex = keymutex.NewKeyMutex()
|
|
|
|
supportedFeatures = sets.NewString("layering")
|
|
)
|
|
|
|
func getRBDKey(id string, credentials map[string]string) (string, error) {
|
|
|
|
if key, ok := credentials[id]; ok {
|
|
return key, nil
|
|
}
|
|
return "", fmt.Errorf("RBD key for ID: %s not found", id)
|
|
}
|
|
|
|
func getMon(pOpts *rbdVolume, credentials map[string]string) (string, error) {
|
|
mon := pOpts.Monitors
|
|
if len(mon) == 0 {
|
|
// if mons are set in secret, retrieve them
|
|
if len(pOpts.MonValueFromSecret) == 0 {
|
|
// yet another sanity check
|
|
return "", fmt.Errorf("either monitors or monValueFromSecret must be set")
|
|
}
|
|
if val, ok := credentials[pOpts.MonValueFromSecret]; !ok {
|
|
return "", fmt.Errorf("mon data %s is not set in secret", pOpts.MonValueFromSecret)
|
|
} else {
|
|
mon = val
|
|
}
|
|
}
|
|
return mon, nil
|
|
}
|
|
|
|
// CreateImage creates a new ceph image with provision and volume options.
|
|
func createRBDImage(pOpts *rbdVolume, volSz int, adminId string, credentials map[string]string) error {
|
|
var output []byte
|
|
|
|
mon, err := getMon(pOpts, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
image := pOpts.VolName
|
|
volSzGB := fmt.Sprintf("%dG", volSz)
|
|
|
|
key, err := getRBDKey(adminId, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if pOpts.ImageFormat == rbdImageFormat2 {
|
|
glog.V(4).Infof("rbd: create %s size %s format %s (features: %s) using mon %s, pool %s id %s key %s", image, volSzGB, pOpts.ImageFormat, pOpts.ImageFeatures, mon, pOpts.Pool, adminId, key)
|
|
} else {
|
|
glog.V(4).Infof("rbd: create %s size %s format %s using mon %s, pool %s id %s key %s", image, volSzGB, pOpts.ImageFormat, mon, pOpts.Pool, adminId, key)
|
|
}
|
|
args := []string{"create", image, "--size", volSzGB, "--pool", pOpts.Pool, "--id", adminId, "-m", mon, "--key=" + key, "--image-format", pOpts.ImageFormat}
|
|
if pOpts.ImageFormat == rbdImageFormat2 {
|
|
args = append(args, "--image-feature", pOpts.ImageFeatures)
|
|
}
|
|
output, err = execCommand("rbd", args)
|
|
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to create rbd image, command output: %s", string(output))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// rbdStatus checks if there is watcher on the image.
|
|
// It returns true if there is a watcher onthe image, otherwise returns false.
|
|
func rbdStatus(pOpts *rbdVolume, userId string, credentials map[string]string) (bool, string, error) {
|
|
var output string
|
|
var cmd []byte
|
|
|
|
image := pOpts.VolName
|
|
// If we don't have admin id/secret (e.g. attaching), fallback to user id/secret.
|
|
|
|
key, err := getRBDKey(userId, credentials)
|
|
if err != nil {
|
|
return false, "", err
|
|
}
|
|
|
|
mon, err := getMon(pOpts, credentials)
|
|
if err != nil {
|
|
return false, "", err
|
|
}
|
|
|
|
glog.V(4).Infof("rbd: status %s using mon %s, pool %s id %s key %s", image, mon, pOpts.Pool, userId, key)
|
|
args := []string{"status", image, "--pool", pOpts.Pool, "-m", mon, "--id", userId, "--key=" + key}
|
|
cmd, err = execCommand("rbd", args)
|
|
output = string(cmd)
|
|
|
|
if err, ok := err.(*exec.Error); ok {
|
|
if err.Err == exec.ErrNotFound {
|
|
glog.Errorf("rbd cmd not found")
|
|
// fail fast if command not found
|
|
return false, output, err
|
|
}
|
|
}
|
|
|
|
// If command never succeed, returns its last error.
|
|
if err != nil {
|
|
return false, output, err
|
|
}
|
|
|
|
if strings.Contains(output, imageWatcherStr) {
|
|
glog.V(4).Infof("rbd: watchers on %s: %s", image, output)
|
|
return true, output, nil
|
|
} else {
|
|
glog.Warningf("rbd: no watchers on %s", image)
|
|
return false, output, nil
|
|
}
|
|
}
|
|
|
|
// DeleteImage deletes a ceph image with provision and volume options.
|
|
func deleteRBDImage(pOpts *rbdVolume, adminId string, credentials map[string]string) error {
|
|
var output []byte
|
|
image := pOpts.VolName
|
|
found, _, err := rbdStatus(pOpts, adminId, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if found {
|
|
glog.Info("rbd is still being used ", image)
|
|
return fmt.Errorf("rbd %s is still being used", image)
|
|
}
|
|
key, err := getRBDKey(adminId, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
mon, err := getMon(pOpts, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
glog.V(4).Infof("rbd: rm %s using mon %s, pool %s id %s key %s", image, mon, pOpts.Pool, adminId, key)
|
|
args := []string{"rm", image, "--pool", pOpts.Pool, "--id", adminId, "-m", mon, "--key=" + key}
|
|
output, err = execCommand("rbd", args)
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
glog.Errorf("failed to delete rbd image: %v, command output: %s", err, string(output))
|
|
return err
|
|
}
|
|
|
|
func execCommand(command string, args []string) ([]byte, error) {
|
|
cmd := exec.Command(command, args...)
|
|
return cmd.CombinedOutput()
|
|
}
|
|
|
|
func getRBDVolumeOptions(volOptions map[string]string) (*rbdVolume, error) {
|
|
var ok bool
|
|
rbdVol := &rbdVolume{}
|
|
rbdVol.Pool, ok = volOptions["pool"]
|
|
if !ok {
|
|
return nil, fmt.Errorf("Missing required parameter pool")
|
|
}
|
|
rbdVol.Monitors, ok = volOptions["monitors"]
|
|
if !ok {
|
|
// if mons are not set in options, check if they are set in secret
|
|
if rbdVol.MonValueFromSecret, ok = volOptions["monValueFromSecret"]; !ok {
|
|
return nil, fmt.Errorf("Either monitors or monValueFromSecret must be set")
|
|
}
|
|
}
|
|
rbdVol.ImageFormat, ok = volOptions["imageFormat"]
|
|
if !ok {
|
|
rbdVol.ImageFormat = rbdImageFormat2
|
|
}
|
|
if rbdVol.ImageFormat == rbdImageFormat2 {
|
|
// if no image features is provided, it results in empty string
|
|
// which disable all RBD image format 2 features as we expected
|
|
imageFeatures, ok := volOptions["imageFeatures"]
|
|
if ok {
|
|
arr := strings.Split(imageFeatures, ",")
|
|
for _, f := range arr {
|
|
if !supportedFeatures.Has(f) {
|
|
return nil, fmt.Errorf("invalid feature %q for volume csi-rbdplugin, supported features are: %v", f, supportedFeatures)
|
|
}
|
|
}
|
|
rbdVol.ImageFeatures = imageFeatures
|
|
}
|
|
|
|
}
|
|
rbdVol.AdminId, ok = volOptions["adminid"]
|
|
if !ok {
|
|
rbdVol.AdminId = rbdDefaultAdminId
|
|
}
|
|
rbdVol.UserId, ok = volOptions["userid"]
|
|
if !ok {
|
|
rbdVol.UserId = rbdDefaultUserId
|
|
}
|
|
rbdVol.Mounter, ok = volOptions["mounter"]
|
|
if !ok {
|
|
rbdVol.Mounter = rbdDefaultMounter
|
|
}
|
|
return rbdVol, nil
|
|
}
|
|
|
|
func getRBDSnapshotOptions(snapOptions map[string]string) (*rbdSnapshot, error) {
|
|
var ok bool
|
|
rbdSnap := &rbdSnapshot{}
|
|
rbdSnap.Pool, ok = snapOptions["pool"]
|
|
if !ok {
|
|
return nil, fmt.Errorf("Missing required parameter pool")
|
|
}
|
|
rbdSnap.Monitors, ok = snapOptions["monitors"]
|
|
if !ok {
|
|
// if mons are not set in options, check if they are set in secret
|
|
if rbdSnap.MonValueFromSecret, ok = snapOptions["monValueFromSecret"]; !ok {
|
|
return nil, fmt.Errorf("Either monitors or monValueFromSecret must be set")
|
|
}
|
|
}
|
|
rbdSnap.AdminId, ok = snapOptions["adminid"]
|
|
if !ok {
|
|
rbdSnap.AdminId = rbdDefaultAdminId
|
|
}
|
|
rbdSnap.UserId, ok = snapOptions["userid"]
|
|
if !ok {
|
|
rbdSnap.UserId = rbdDefaultUserId
|
|
}
|
|
|
|
return rbdSnap, nil
|
|
}
|
|
|
|
func hasSnapshotFeature(imageFeatures string) bool {
|
|
arr := strings.Split(imageFeatures, ",")
|
|
for _, f := range arr {
|
|
if f == "layering" {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func persistVolInfo(image string, persistentStoragePath string, volInfo *rbdVolume) error {
|
|
file := path.Join(persistentStoragePath, image+".json")
|
|
fp, err := os.Create(file)
|
|
if err != nil {
|
|
glog.Errorf("rbd: failed to create persistent storage file %s with error: %v\n", file, err)
|
|
return errors.Wrapf(err, "rbd: create error for %s", file)
|
|
}
|
|
defer fp.Close()
|
|
encoder := json.NewEncoder(fp)
|
|
if err = encoder.Encode(volInfo); err != nil {
|
|
glog.Errorf("rbd: failed to encode volInfo: %+v for file: %s with error: %v\n", volInfo, file, err)
|
|
return errors.Wrap(err, "rbd: encode error")
|
|
}
|
|
glog.Infof("rbd: successfully saved volInfo: %+v into file: %s\n", volInfo, file)
|
|
return nil
|
|
}
|
|
|
|
func loadVolInfo(image string, persistentStoragePath string, volInfo *rbdVolume) error {
|
|
file := path.Join(persistentStoragePath, image+".json")
|
|
fp, err := os.Open(file)
|
|
if err != nil {
|
|
return errors.Wrapf(err, "rbd: open error for %s", file)
|
|
}
|
|
defer fp.Close()
|
|
|
|
decoder := json.NewDecoder(fp)
|
|
if err = decoder.Decode(volInfo); err != nil {
|
|
return errors.Wrap(err, "rbd: decode error")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func deleteVolInfo(image string, persistentStoragePath string) error {
|
|
file := path.Join(persistentStoragePath, image+".json")
|
|
glog.Infof("rbd: Deleting file for Volume: %s at: %s resulting path: %+v\n", image, persistentStoragePath, file)
|
|
err := os.Remove(file)
|
|
if err != nil {
|
|
if err != os.ErrNotExist {
|
|
return errors.Wrapf(err, "rbd: error removing file %s", file)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func persistSnapInfo(snapshot string, persistentStoragePath string, snapInfo *rbdSnapshot) error {
|
|
file := path.Join(persistentStoragePath, snapshot+".json")
|
|
fp, err := os.Create(file)
|
|
if err != nil {
|
|
glog.Errorf("rbd: failed to create persistent storage file %s with error: %v\n", file, err)
|
|
return errors.Wrapf(err, "rbd: create error for %s", file)
|
|
}
|
|
defer fp.Close()
|
|
encoder := json.NewEncoder(fp)
|
|
if err = encoder.Encode(snapInfo); err != nil {
|
|
glog.Errorf("rbd: failed to encode snapInfo: %+v for file: %s with error: %v\n", snapInfo, file, err)
|
|
return errors.Wrap(err, "rbd: encode error")
|
|
}
|
|
glog.Infof("rbd: successfully saved snapInfo: %+v into file: %s\n", snapInfo, file)
|
|
return nil
|
|
}
|
|
|
|
func loadSnapInfo(snapshot string, persistentStoragePath string, snapInfo *rbdSnapshot) error {
|
|
file := path.Join(persistentStoragePath, snapshot+".json")
|
|
fp, err := os.Open(file)
|
|
if err != nil {
|
|
return errors.Wrapf(err, "rbd: open error for %s", file)
|
|
}
|
|
defer fp.Close()
|
|
|
|
decoder := json.NewDecoder(fp)
|
|
if err = decoder.Decode(snapInfo); err != nil {
|
|
return errors.Wrap(err, "rbd: decode error")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func deleteSnapInfo(snapshot string, persistentStoragePath string) error {
|
|
file := path.Join(persistentStoragePath, snapshot+".json")
|
|
glog.Infof("rbd: Deleting file for Snapshot: %s at: %s resulting path: %+v\n", snapshot, persistentStoragePath, file)
|
|
err := os.Remove(file)
|
|
if err != nil {
|
|
if err != os.ErrNotExist {
|
|
return errors.Wrapf(err, "rbd: error removing file %s", file)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func getRBDVolumeByID(volumeID string) (*rbdVolume, error) {
|
|
if rbdVol, ok := rbdVolumes[volumeID]; ok {
|
|
return rbdVol, nil
|
|
}
|
|
return nil, fmt.Errorf("volume id %s does not exit in the volumes list", volumeID)
|
|
}
|
|
|
|
func getRBDVolumeByName(volName string) (*rbdVolume, error) {
|
|
for _, rbdVol := range rbdVolumes {
|
|
if rbdVol.VolName == volName {
|
|
return rbdVol, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("volume name %s does not exit in the volumes list", volName)
|
|
}
|
|
|
|
func getRBDSnapshotByName(snapName string) (*rbdSnapshot, error) {
|
|
for _, rbdSnap := range rbdSnapshots {
|
|
if rbdSnap.SnapName == snapName {
|
|
return rbdSnap, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("snapshot name %s does not exit in the snapshots list", snapName)
|
|
}
|
|
|
|
func getSnapMon(pOpts *rbdSnapshot, credentials map[string]string) (string, error) {
|
|
mon := pOpts.Monitors
|
|
if len(mon) == 0 {
|
|
// if mons are set in secret, retrieve them
|
|
if len(pOpts.MonValueFromSecret) == 0 {
|
|
// yet another sanity check
|
|
return "", fmt.Errorf("either monitors or monValueFromSecret must be set")
|
|
}
|
|
if val, ok := credentials[pOpts.MonValueFromSecret]; !ok {
|
|
return "", fmt.Errorf("mon data %s is not set in secret", pOpts.MonValueFromSecret)
|
|
} else {
|
|
mon = val
|
|
}
|
|
}
|
|
return mon, nil
|
|
}
|
|
|
|
func protectSnapshot(pOpts *rbdSnapshot, adminId string, credentials map[string]string) error {
|
|
var output []byte
|
|
|
|
image := pOpts.VolName
|
|
snapID := pOpts.SnapID
|
|
|
|
key, err := getRBDKey(adminId, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
mon, err := getSnapMon(pOpts, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
glog.V(4).Infof("rbd: snap protect %s using mon %s, pool %s id %s key %s", image, mon, pOpts.Pool, adminId, key)
|
|
args := []string{"snap", "protect", "--pool", pOpts.Pool, "--snap", snapID, image, "--id", adminId, "-m", mon, "--key=" + key}
|
|
|
|
output, err = execCommand("rbd", args)
|
|
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to protect snapshot, command output: %s", string(output))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func createSnapshot(pOpts *rbdSnapshot, adminId string, credentials map[string]string) error {
|
|
var output []byte
|
|
|
|
mon, err := getSnapMon(pOpts, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
image := pOpts.VolName
|
|
snapID := pOpts.SnapID
|
|
|
|
key, err := getRBDKey(adminId, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
glog.V(4).Infof("rbd: snap create %s using mon %s, pool %s id %s key %s", image, mon, pOpts.Pool, adminId, key)
|
|
args := []string{"snap", "create", "--pool", pOpts.Pool, "--snap", snapID, image, "--id", adminId, "-m", mon, "--key=" + key}
|
|
|
|
output, err = execCommand("rbd", args)
|
|
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to create snapshot, command output: %s", string(output))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func unprotectSnapshot(pOpts *rbdSnapshot, adminId string, credentials map[string]string) error {
|
|
var output []byte
|
|
|
|
mon, err := getSnapMon(pOpts, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
image := pOpts.VolName
|
|
snapID := pOpts.SnapID
|
|
|
|
key, err := getRBDKey(adminId, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
glog.V(4).Infof("rbd: snap unprotect %s using mon %s, pool %s id %s key %s", image, mon, pOpts.Pool, adminId, key)
|
|
args := []string{"snap", "unprotect", "--pool", pOpts.Pool, "--snap", snapID, image, "--id", adminId, "-m", mon, "--key=" + key}
|
|
|
|
output, err = execCommand("rbd", args)
|
|
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to unprotect snapshot, command output: %s", string(output))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func deleteSnapshot(pOpts *rbdSnapshot, adminId string, credentials map[string]string) error {
|
|
var output []byte
|
|
|
|
mon, err := getSnapMon(pOpts, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
image := pOpts.VolName
|
|
snapID := pOpts.SnapID
|
|
|
|
key, err := getRBDKey(adminId, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
glog.V(4).Infof("rbd: snap rm %s using mon %s, pool %s id %s key %s", image, mon, pOpts.Pool, adminId, key)
|
|
args := []string{"snap", "rm", "--pool", pOpts.Pool, "--snap", snapID, image, "--id", adminId, "-m", mon, "--key=" + key}
|
|
|
|
output, err = execCommand("rbd", args)
|
|
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to delete snapshot, command output: %s", string(output))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func restoreSnapshot(pVolOpts *rbdVolume, pSnapOpts *rbdSnapshot, adminId string, credentials map[string]string) error {
|
|
var output []byte
|
|
|
|
mon, err := getMon(pVolOpts, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
image := pVolOpts.VolName
|
|
snapID := pSnapOpts.SnapID
|
|
|
|
key, err := getRBDKey(adminId, credentials)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
glog.V(4).Infof("rbd: clone %s using mon %s, pool %s id %s key %s", image, mon, pVolOpts.Pool, adminId, key)
|
|
args := []string{"clone", pSnapOpts.Pool + "/" + pSnapOpts.VolName + "@" + snapID, pVolOpts.Pool + "/" + image, "--id", adminId, "-m", mon, "--key=" + key}
|
|
|
|
output, err = execCommand("rbd", args)
|
|
|
|
if err != nil {
|
|
return errors.Wrapf(err, "failed to restore snapshot, command output: %s", string(output))
|
|
}
|
|
|
|
return nil
|
|
}
|